blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
410
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
51
| license_type
stringclasses 2
values | repo_name
stringlengths 5
132
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringlengths 4
80
| visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 5.85k
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
listlengths 1
1
| author_id
stringlengths 0
313
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b36751497d172b206d6775d6685176909aab9b5a
|
77a887ac7cb230292a1b77f212830993bef4aa4d
|
/src/main/java/com/wps/web/template/web/Add.java
|
171250dbda7904d2871ed6ba2995867ae1e0e72a
|
[] |
no_license
|
dark-arc/wps-java-tutorial
|
95a23a70bfd06f51612c246a26a435b44f8fb310
|
647e08875d8e0de1a366bc81208c825daf96929e
|
refs/heads/master
| 2021-01-23T16:05:54.530332 | 2017-09-07T10:23:16 | 2017-09-07T10:23:16 | 102,723,358 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 824 |
java
|
package com.wps.web.template.web;
import javax.annotation.security.PermitAll;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
@PermitAll
@Path("/add")
@Produces(MediaType.APPLICATION_JSON)
public class Add {
public Add() {
}
@GET
public Response addNumbers(@QueryParam("a") int a, @QueryParam("b") int b) {
AdditionQueryResult result = new AdditionQueryResult();
result.result = a+b;
return Response.ok(result).build();
}
@POST
public Response addNumbers(AdditionQueryParameters p) {
AdditionQueryResult result = new AdditionQueryResult();
result.result = p.a + p.b;
return Response.ok(result).build();
}
}
|
[
"[email protected]"
] | |
3bc40d05f5999e968a409758f0a33b4ee12c51d2
|
2b9dbe80c039641fb3b518ee4444b8978c48afa7
|
/src/com/company/PageComparatorInterface.java
|
25373fe6f5c0fe7bed8b91ed88ea5164a85654b5
|
[] |
no_license
|
simonusher/frame-assignment-algorithms
|
208103b5197b74f91a2fbcfc13ebab4e91f71e8b
|
521d639eda6df97e3803d5851ba35ecf6434e558
|
refs/heads/master
| 2023-04-18T09:37:17.766872 | 2017-05-22T18:08:10 | 2017-05-22T18:08:10 | 365,306,565 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 153 |
java
|
package com.company;
/**
* Created by Szymon on 24.04.2017.
*/
public interface PageComparatorInterface {
public int compare(Page p1, Page p2);
}
|
[
"[email protected]"
] | |
1099d0fe67875974e687671b14ee81782a206661
|
297aa14030ca7a285229d4096ef526c2d8c0cee9
|
/src/main/java/spring/condition/WindowsListService.java
|
7e5e157bd39f4a79865190945be9e5c562603824
|
[] |
no_license
|
1064447034/thinkjava
|
2311cd84f7b30d401daae7ca4ac6f6d63b73e1c5
|
c08e4c3635fa068f9bae485ea18209c7fd502b03
|
refs/heads/master
| 2020-04-06T13:22:26.096788 | 2019-01-02T05:48:48 | 2019-01-02T05:48:48 | 157,496,979 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 302 |
java
|
package spring.condition;
import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Service;
@Service
@Conditional(WindowsCondition.class)
public class WindowsListService implements ListService {
@Override
public String showListCmd() {
return "dir";
}
}
|
[
"[email protected]"
] | |
31e12dcdfcb8d80a4f15feff55ba4d8ca8a21c84
|
5253fca4b43333689a7da7aee166479ed7bf41f4
|
/src/main/java/eu/hlavki/vacation/Vacations.java
|
c75315939b233d6c1940f338d67c92dd0ad560e5
|
[] |
no_license
|
hlavki/dovolenka
|
5c9bdac5c78760ee97601f8c652fff207112eadc
|
a6c1625747a7167fef593017908e89a1b89ae0f6
|
refs/heads/master
| 2020-06-17T16:02:25.768078 | 2019-07-09T08:57:19 | 2019-07-09T08:57:19 | 195,971,050 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,352 |
java
|
package eu.hlavki.vacation;
import biweekly.Biweekly;
import biweekly.ICalendar;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static java.util.stream.Collectors.toList;
import java.util.stream.Stream;
public class Vacations {
private final List<Vacation> vacations;
private final Set<LocalDate> holidays;
public Vacations(List<Vacation> vacations, Set<LocalDate> holidays) {
this.vacations = vacations;
this.holidays = holidays;
}
Stream<LocalDate> stream() {
return vacations.stream()
.flatMap(v -> v.stream())
.filter(d -> !holidays.contains(d))
.filter(d -> (d.getDayOfWeek() != DayOfWeek.SATURDAY) && (d.getDayOfWeek() != DayOfWeek.SUNDAY));
}
public static Vacations parse(String icalFile, String searchString) {
return parse(icalFile, searchString, "/sviatky.txt");
}
public static Vacations parse(String icalFile, String searchString, String holidaysFile) {
List<Vacation> vacations = new ArrayList<>();
try (InputStream in = new FileInputStream(icalFile)) {
ICalendar ical = Biweekly.parse(in).first();
vacations = ical.getEvents().stream()
.filter(e -> e.getSummary().getValue().toLowerCase().contains(searchString.toLowerCase()))
.map(e -> new Vacation(e.getDateStart().getValue(), e.getDateEnd().getValue()))
.collect(toList());
} catch (IOException e) {
e.printStackTrace();
}
Set<LocalDate> holidays = new HashSet<>();
try (BufferedReader reader = new BufferedReader(new InputStreamReader(Vacations.class.getResourceAsStream(holidaysFile)))) {
String line;
while ((line = reader.readLine()) != null) {
LocalDate date = LocalDate.parse(line.trim());
holidays.add(date);
}
} catch (IOException e) {
e.printStackTrace();
}
return new Vacations(vacations, holidays);
}
}
|
[
"[email protected]"
] | |
a6bfd0d07af46e1c5829d0adbacfc49bf4ebef07
|
7b9237021c80b3e65f43437f374183c49ac83675
|
/app/src/main/java/com/blogspot/ketikanmd/agenda/LoginActivity.java
|
0a2a119a526343b5ee6f92c013acbe0ed154e48f
|
[] |
no_license
|
januarst/CatatanAgenda
|
931449deb24844a146b38730d4ff62fe32762c2e
|
d3906db1a2dd9d46af871ac39a82f67afd5d9207
|
refs/heads/master
| 2022-02-01T12:56:13.945970 | 2019-05-19T14:23:23 | 2019-05-19T14:23:23 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 5,304 |
java
|
package com.blogspot.ketikanmd.agenda;
import android.content.Intent;
import android.os.Bundle;
import android.support.design.widget.Snackbar;
import android.support.design.widget.TextInputLayout;
import android.support.v7.app.AppCompatActivity;
import android.text.Html;
import android.text.Spanned;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import com.blogspot.ketikanmd.appcatatanagenda.R;
public class LoginActivity extends AppCompatActivity {
//Declaration EditTexts
EditText editTextEmail;
EditText editTextPassword;
//Declaration TextInputLayout
TextInputLayout textInputLayoutEmail;
TextInputLayout textInputLayoutPassword;
//Declaration Button
Button buttonLogin;
//Declaration SqliteHelper
SqliteHelper sqliteHelper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
sqliteHelper = new SqliteHelper(this);
initCreateAccountTextView();
initViews();
//set click event of login button
buttonLogin.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//Check user input is correct or not
if (validate()) {
//Get values from EditText fields
String Email = editTextEmail.getText().toString();
String Password = editTextPassword.getText().toString();
//Authenticate user
User currentUser = sqliteHelper.Authenticate(new User(null, null, Email, Password));
//Check Authentication is successful or not
if (currentUser != null) {
Snackbar.make(buttonLogin, "Successfully Logged in!", Snackbar.LENGTH_LONG).show();
//User Logged in Successfully Launch You home screen activity
Intent intent=new Intent(LoginActivity.this,MainActivity.class);
startActivity(intent);
finish();
} else {
//User Logged in Failed
Snackbar.make(buttonLogin, "Failed to log in , please try again", Snackbar.LENGTH_LONG).show();
}
}
}
});
}
//this method used to set Create account TextView text and click event( maltipal colors
// for TextView yet not supported in Xml so i have done it programmatically)
private void initCreateAccountTextView() {
TextView textViewCreateAccount = (TextView) findViewById(R.id.textViewCreateAccount);
textViewCreateAccount.setText(fromHtml("<font color='#ffffff'>I don't have account yet. </font><font color='#0c0099'>create one</font>"));
textViewCreateAccount.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(LoginActivity.this, RegisterActivity.class);
startActivity(intent);
}
});
}
//this method is used to connect XML views to its Objects
private void initViews() {
editTextEmail = (EditText) findViewById(R.id.editTextEmail);
editTextPassword = (EditText) findViewById(R.id.editTextPassword);
textInputLayoutEmail = (TextInputLayout) findViewById(R.id.textInputLayoutEmail);
textInputLayoutPassword = (TextInputLayout) findViewById(R.id.textInputLayoutPassword);
buttonLogin = (Button) findViewById(R.id.buttonLogin);
}
//This method is for handling fromHtml method deprecation
@SuppressWarnings("deprecation")
public static Spanned fromHtml(String html) {
Spanned result;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
result = Html.fromHtml(html, Html.FROM_HTML_MODE_LEGACY);
} else {
result = Html.fromHtml(html);
}
return result;
}
//This method is used to validate input given by user
public boolean validate() {
boolean valid = false;
//Get values from EditText fields
String Email = editTextEmail.getText().toString();
String Password = editTextPassword.getText().toString();
//Handling validation for Email field
if (!android.util.Patterns.EMAIL_ADDRESS.matcher(Email).matches()) {
valid = false;
textInputLayoutEmail.setError("Please enter valid email!");
} else {
valid = true;
textInputLayoutEmail.setError(null);
}
//Handling validation for Password field
if (Password.isEmpty()) {
valid = false;
textInputLayoutPassword.setError("Please enter valid password!");
} else {
if (Password.length() > 5) {
valid = true;
textInputLayoutPassword.setError(null);
} else {
valid = false;
textInputLayoutPassword.setError("Password is to short!");
}
}
return valid;
}
}
|
[
"[email protected]"
] | |
a7639c0929a29cabef28980721509b6f63ce7981
|
c28b037d7d1356c0f3ac25346f2e2d98e1a3604f
|
/src/main/java/com/bps/dao/PaymentMethodDAOImpl.java
|
a504927d3b713cedf9bf70648cb71c9fedf0ea81
|
[] |
no_license
|
suntomoon/BPS
|
97ee966eec12396b5327a6757c71f2351ca795db
|
5b05943c5c6768a68a61c6d0371da7fa4ad80635
|
refs/heads/master
| 2016-09-05T22:21:00.772604 | 2015-02-23T02:35:05 | 2015-02-23T02:35:05 | 23,049,984 | 0 | 0 | null | 2014-08-18T20:31:18 | 2014-08-17T20:40:28 |
Java
|
UTF-8
|
Java
| false | false | 1,061 |
java
|
package com.bps.dao;
import java.util.List;
import org.hibernate.SessionFactory;
import com.bps.abstarct.AbstractEntity;
import com.bps.entity.PaymentMethodEntity;
public class PaymentMethodDAOImpl extends RWDAO {
@SuppressWarnings("unchecked")
@Override
public List<AbstractEntity> getAllEntity() {
return this.sessionFactory.getCurrentSession().createQuery("from PaymentMethodEntity").list();
}
@Override
public void deleteEntity(int entityId) {
PaymentMethodEntity entity = (PaymentMethodEntity) sessionFactory.getCurrentSession()
.load(PaymentMethodEntity.class, entityId);
if (null != entity) {
this.sessionFactory.getCurrentSession().delete(entity);
}
}
@Override
public PaymentMethodEntity getEntityById(int entityId) {
PaymentMethodEntity entity = (PaymentMethodEntity) sessionFactory.getCurrentSession()
.load(PaymentMethodEntity.class, entityId);
return entity;
}
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
}
|
[
"[email protected]"
] | |
a6cebec5bb3accf2db7ba6d93a7580f8c3c8b290
|
d412437c299d1fb7cc71be80da2064f04c3b35bf
|
/app/src/main/java/com/llorca/verifyschool/SecondActivity.java
|
ad237e5bc3d01d15664e8b6061602bbe5d1e7241
|
[] |
no_license
|
AriesKyleLlorca/LabExer2
|
4f4a904e3ddc60afe766aef246ded5b5fa61833a
|
b6cd9a68b1ec0556b61bebc36f0717acb9951ed8
|
refs/heads/master
| 2020-07-29T17:55:31.952995 | 2019-09-21T02:05:10 | 2019-09-21T02:05:10 | 209,910,366 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,530 |
java
|
package com.llorca.verifyschool;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
public class SecondActivity extends AppCompatActivity{
SharedPreferences sp;
EditText etVerifySchool;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
etVerifySchool = findViewById(R.id.et_VerifySchool);
}
public void verify(View v){
sp = getSharedPreferences("data1", MODE_PRIVATE);
String school1 = sp.getString("sschool1", null);
String school2 = sp.getString("sschool2", null);
String school3 = sp.getString("sschool3", null);
String school4 = sp.getString("sschool4", null);
String school5 = sp.getString("sschool5", null);
String school6 = sp.getString("sschool6", null);
String school7 = sp.getString("sschool7", null);
String school8 = sp.getString("sschool8", null);
String verifySchool = etVerifySchool.getText().toString();
if(school1.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else if(school2.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else if(school3.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else if(school4.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else if(school5.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else if(school6.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else if(school7.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else if(school8.equals(verifySchool)){
Toast.makeText(this, "School is competing in UAAP...", Toast.LENGTH_LONG).show();
}
else{
Toast.makeText(this, "School is not competing in UAAP...", Toast.LENGTH_LONG).show();
}
}
}
|
[
"[email protected]"
] | |
3fcb57562c7354b48578ec98f0a1c23f5d2b59e6
|
f30a28c5d04506cced427ebc610b09b6c8ff141f
|
/src/main/java/bitcamp/java89/ems2/servlet/student/StudentUpdateServlet.java
|
20db82b00dc940de63fec023a5694d80d8acbac3
|
[] |
no_license
|
HeuikyungKim/bitcamp-project-web2
|
902427486c5b48777d28110ebdae6cbafc93e86c
|
1cf559d0bcacaa9b92aa320cc2e2e6fd4b218a4f
|
refs/heads/master
| 2021-01-12T06:49:41.408590 | 2016-12-21T01:02:00 | 2016-12-21T01:02:00 | 76,836,376 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,466 |
java
|
package bitcamp.java89.ems2.servlet.student;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import bitcamp.java89.ems2.dao.impl.MemberMysqlDao;
import bitcamp.java89.ems2.dao.impl.StudentMysqlDao;
import bitcamp.java89.ems2.domain.Student;
@WebServlet("/student/update")
public class StudentUpdateServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
Student student = new Student();
student.setMemberNo(Integer.parseInt(request.getParameter("memberNo")));
student.setEmail(request.getParameter("email"));
student.setPassword(request.getParameter("password"));
student.setName(request.getParameter("name"));
student.setTel(request.getParameter("tel"));
student.setWorking(Boolean.parseBoolean(request.getParameter("working")));
student.setGrade(request.getParameter("grade"));
student.setSchoolName(request.getParameter("schoolName"));
student.setPhotoPath(request.getParameter("photoPath"));
response.setHeader("Refresh", "1;url=list");
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head>");
out.println("<meta charset='UTF-8'>");
out.println("<title>학생관리-변경</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>학생 결과</h1>");
try {
StudentMysqlDao studentDao = StudentMysqlDao.getInstance();
if (!studentDao.exist(student.getMemberNo())) {
throw new Exception("사용자를 찾지 못했습니다.");
}
MemberMysqlDao memberDao = MemberMysqlDao.getInstance();
memberDao.update(student);
studentDao.update(student);
out.println("<p>변경 하였습니다.</p>");
} catch (Exception e) {
out.printf("<p>%s</p>\n", e.getMessage());
}
out.println("</body>");
out.println("</html>");
}
}
|
[
"[email protected]"
] | |
645a24f9e6bbd37f6e7869ee33f3d768966dae5b
|
b3ec7b9aa29efa64bce578f1a4a3e875dfdc9fb1
|
/hw07-todo-structural-paterns/src/main/java/ru/otus/processor/homework/SwitchProcessor.java
|
8751a73eda7647b6c3b5c1cc06c25cd329de85ff
|
[] |
no_license
|
ArtyomZoloto/2020-06-otus-java-Zolotoverkhov
|
5a3a51d8bdc831f74ba1a642eb3896ede3102190
|
62f6fc114c0facc7020ea5a391e2b27e62dc2924
|
refs/heads/master
| 2023-03-13T23:46:13.342452 | 2021-03-01T18:20:44 | 2021-03-01T18:20:44 | 276,190,370 | 0 | 0 | null | 2021-03-01T18:20:45 | 2020-06-30T19:28:38 |
Java
|
UTF-8
|
Java
| false | false | 449 |
java
|
package ru.otus.processor.homework;
import ru.otus.Message;
import ru.otus.processor.Processor;
/**
* This processor should switch data between fiedl11 and field 12
*/
public class SwitchProcessor implements Processor {
@Override
public Message process(Message message) {
return message.toBuilder()
.field11(message.getField12())
.field12(message.getField11())
.build();
}
}
|
[
"[email protected]"
] | |
c4a1faf5659bc3b78d40a5915c8acafcce5df463
|
d2079ad53494fc8db2bd75bd1f574a289919337a
|
/src/main/java/BesentTech/CallToAll/Reporting/Logging.java
|
213554e1357fc8871f20f56f4f3f50b450cc999b
|
[] |
no_license
|
Ankit11191/CallToAll
|
7d6e243c1d2cdfe44f87b65ddee6dabc3af6da2e
|
0ecab06b6c1cf621419eb19a284879dafde5b4bc
|
refs/heads/main
| 2023-02-05T00:02:59.189617 | 2020-12-18T17:06:29 | 2020-12-18T17:06:29 | 322,038,961 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 580 |
java
|
package BesentTech.CallToAll.Reporting;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import BesentTech.CallToAll.configuration.PublicContext;
public class Logging {
public static Logger logger=Logger.getLogger(new Object() {}.getClass().getEnclosingClass());
static {
System.setProperty("log.FilePath", PublicContext.logPath);
System.setProperty("log.timestamp", new SimpleDateFormat("dd_MMM_yyyy").format(new Date()));
PropertyConfigurator.configure("log4j.properties");
}
}
|
[
"[email protected]"
] | |
00d898f45199b1788418d39add4019c9a35f0976
|
007364d2a8803853f41534d547bd9e66ab66e240
|
/app/src/main/java/com/maple/demo/myarms/mvp/ui/activity/RegisteActivity.java
|
b1cf14bba8de01cc125821a51a8e384ba33a7beb
|
[] |
no_license
|
gaoguanqi/MyArms
|
70657a2d69460a4c56587aee3773bc8ba497f229
|
efb61d72b99c81aa654b5945322ac1baea95abdf
|
refs/heads/master
| 2020-04-11T21:15:07.343476 | 2019-04-12T09:42:44 | 2019-04-12T09:42:44 | 162,099,707 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,813 |
java
|
package com.maple.demo.myarms.mvp.ui.activity;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import com.jess.arms.di.component.AppComponent;
import com.jess.arms.utils.ArmsUtils;
import com.jess.arms.utils.RxLifecycleUtils;
import com.maple.demo.myarms.R;
import com.maple.demo.myarms.app.base.BaseViewActivity;
import com.maple.demo.myarms.app.manager.toolbar.ToolbarConfig;
import com.maple.demo.myarms.di.component.DaggerRegisteComponent;
import com.maple.demo.myarms.di.module.RegisteModule;
import com.maple.demo.myarms.mvp.contract.RegisteContract;
import com.maple.demo.myarms.mvp.model.api.ApiService;
import com.maple.demo.myarms.mvp.presenter.RegistePresenter;
import com.maple.demo.myarms.utils.LogUtils;
import com.maple.demo.myarms.utils.ToastUtil;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
import me.jessyan.rxerrorhandler.handler.ErrorHandleSubscriber;
import static com.jess.arms.utils.Preconditions.checkNotNull;
public class RegisteActivity extends BaseViewActivity<RegistePresenter> implements RegisteContract.View {
@Override
public void setupActivityComponent(@NonNull AppComponent appComponent) {
DaggerRegisteComponent //如找不到该类,请编译一下项目
.builder()
.appComponent(appComponent)
.registeModule(new RegisteModule(this))
.build()
.inject(this);
}
@Override
public int initView(@Nullable Bundle savedInstanceState) {
return R.layout.activity_registe; //如果你不需要框架帮你设置 setContentView(id) 需要自行设置,请返回 0
}
@Override
public void initData(@Nullable Bundle savedInstanceState) {
String id = "10011";
mPresenter.getTest(id);
}
@Override
public void showLoading() {
}
@Override
public void hideLoading() {
}
@Override
public void showMessage(@NonNull String message) {
checkNotNull(message);
ToastUtil.showToast(message);
}
@Override
public void launchActivity(@NonNull Intent intent) {
checkNotNull(intent);
ArmsUtils.startActivity(intent);
}
@Override
public void killMyself() {
finish();
}
@Override
protected ToolbarConfig getToolbarConfig() {
return ToolbarConfig.builder()
.setTitle("注册")
.setToolbarLitener(this)
.build();
}
@Override
protected void onToolbarBack() {
killMyself();
}
@Override
protected boolean useMultipleStatusView() {
return false;
}
}
|
[
"[email protected]"
] | |
d13c840a6eedd3fc5ea196fa4278333df9769c0f
|
d43db4f8385ec39b1ca42377a169d3b5e37b4bc4
|
/src/main/java/command/Receiver.java
|
540ebd44c985a82717d9ba4895f565a9588176e4
|
[] |
no_license
|
jinchuanchuan/design-patterns
|
7d6848d5fce076ba947bf1781a4c81f16244143c
|
3af94988fae6dba15c8908a724f861ede5b9088c
|
refs/heads/master
| 2020-03-29T05:27:51.966545 | 2019-04-22T13:32:14 | 2019-04-22T13:32:14 | 149,583,286 | 0 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 141 |
java
|
package command;
public class Receiver {
public void doSomething(){
System.out.println("接受者-业务逻辑处理");
}
}
|
[
"[email protected]"
] | |
2e5a699ff2e3e4b9c9ecf184fc013644edab053a
|
5b09953fc3e1781862a16fb49e7ad02ff177391b
|
/talleres/taller10/binarytree.java
|
e15505cd1e9f5b22176e40abf44a340513a7907d
|
[] |
no_license
|
jdacevedo10/ST0245-033
|
16a55ca0e07e9a77bb5530061e5089d317569245
|
7fe60aa4746cd03a49eccbeb1021d4ffe18cdf15
|
refs/heads/master
| 2020-06-22T02:03:22.683934 | 2019-10-21T23:55:41 | 2019-10-21T23:55:41 | 197,606,648 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,423 |
java
|
public class binarytree {
public Node root;
public void insert(int n) {
if (root == null) {
root = new Node(n);
} else {
insertAux(root, n);
}
}
private void insertAux(Node node, int n) {
if (node == null) {
node = new Node(n);
}
if (n > node.data) {
if (node.right == null) {
node.right = new Node(n);
}
insertAux(node.right, n);
}
if (n < node.data) {
if (node.left == null) {
node.left = new Node(n);
}
insertAux(node.left, n);
}
}
public boolean buscar(int n) {
return buscarAux(root, n);
}
private boolean buscarAux(Node node, int n) {
if (node == null) {
return false;
}
if (n == node.data) {
return true;
}
if(n < node.data){
return buscarAux(node.left, n);
}else{
return buscarAux(node.right, n);
}
}
public void borrar(int n) {
borrarAux(root, n);
}
private Node borrarAux(Node node, int n) {
}
/*
private void recursivePrintAUX(Node node)
{
if (node != null)
{
recursivePrintAUX(node.left);
recursivePrintAUX(node.right);
System.out.println(node.data);
}
}
public void recursivePrint()
{
recursivePrintAUX(root);
}
}
|
[
"[email protected]"
] | |
d41393db236599731f003ce38ebf37e20c490bd9
|
71e27a0f2d8fa3da23341e1db2f3ef5cafee7cc7
|
/src/main/java/VirtualPet.java
|
1634202d3862f63ccf60435d0c7bc8f11aaf5412
|
[] |
no_license
|
KariNoir/virtual-pet
|
1309c4c121fcaeac5f1e0e8be64381b2cf885af3
|
c93cf50c0ba27e256443fe3f4aeb666932158ef3
|
refs/heads/master
| 2020-12-09T15:35:54.844866 | 2020-01-14T04:51:54 | 2020-01-14T04:51:54 | 233,342,838 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 900 |
java
|
//import java.util.Scanner;
public class VirtualPet {
//private String petName;
private int eat;
private int sleep;
private int fun;
private int potty;
//private final int MAX_EAT, MAX_SLEEP, MAX_FUN, MAX_POTTY;
public VirtualPet(int eat, int sleep, int fun, int potty) {
this.eat = eat;
this.sleep = sleep;
this.fun = fun;
this.potty = potty;
}
public void tick() {
eat--;
sleep--;
fun--;
potty--;
}
public int forEat() {
return eat;
}
public int forSleep() {
return sleep;
}
public int forFun() {
return fun;
}
public int forPotty() {
return potty;
}
public void fedPet() {
this.eat += 3;
this.sleep += 1;
this.potty -= 4;
}
public void goPotty() {
this.eat -= 2;
this.fun += 2;
this.potty += 4;
}
public void haveFun() {
this.sleep -= 3;
this.eat -= 2;
this.fun += 4;
}
public void getSleep() {
this.sleep += 2;
this.potty -=2;
this.eat += 2;
}
}
|
[
"[email protected]"
] | |
743416bf13aa4bc41b024630b71e82833592a84d
|
0e1b399778feeaff58650d30ce50367e73343529
|
/app/src/main/java/sg/edu/rp/c346/demoandroidlist/MainActivity.java
|
44ab8164ded287f9f58c5b196ce3bea3640e9ea4
|
[] |
no_license
|
MINGLINXU/DemoAndroidList
|
64d7e49b3c93edc656bbb23d51482702d8944cfa
|
bc683e1767d3b42531e3c5841b553d63d3c5401d
|
refs/heads/master
| 2020-06-19T02:06:53.022146 | 2019-07-12T07:07:13 | 2019-07-12T07:07:13 | 196,527,331 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,235 |
java
|
package sg.edu.rp.c346.demoandroidlist;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import java.util.ArrayList;
import sg.edu.rp.c346.demoandroidlist.R;
public class MainActivity extends AppCompatActivity {
ListView lvAndroidList;
ArrayList<AndroidVersion> androidVersionArrayList = new ArrayList<AndroidVersion>();
ArrayAdapter<String> aaVersion;
CustomAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
lvAndroidList = findViewById(R.id.listViewMovie);
androidVersionArrayList.add(new AndroidVersion("Pie ", "9.0"));
androidVersionArrayList.add(new AndroidVersion("Oreo", "8.0 - 8.1"));
androidVersionArrayList.add(new AndroidVersion("Nougat", "7.0 - 7.1.2"));
//aaVersion = new ArrayAdapter(this,android.R.layout.simple_list_item_1,androidVersionArrayList);
adapter = new CustomAdapter(this, R.layout.row,androidVersionArrayList);
//lvAndroidList.setAdapter(aaVersion);
lvAndroidList.setAdapter(adapter);
}
}
|
[
"[email protected]"
] | |
c12ae2d052f28691db67dc259c03c38bcbcc06a0
|
4d9d48359286b55e1d01ada39b4a5286add2eae6
|
/src/main/java/weka/gui/beans/ImageListener.java
|
ec672dd7d5cad8749c7f8680d033ecdfb35763a2
|
[] |
no_license
|
Mihir2/HCoreDist
|
969ead235abf42aa3c6779482a80caae61acbcca
|
c23eebc1777e95398308909506bad75308412874
|
refs/heads/master
| 2021-04-15T18:06:08.584262 | 2018-03-24T17:18:43 | 2018-03-24T17:18:43 | 126,339,452 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,220 |
java
|
/*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* ImageListener.java
* Copyright (C) 2011-2012 University of Waikato, Hamilton, New Zealand
*
*/
package weka.gui.beans;
import java.util.EventListener;
/**
* Interface to something that can process an ImageEvent
*
* @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
* @version $Revision$
*/
public interface ImageListener extends EventListener {
/**
* Accept and process an ImageEvent
*
* @param image the image to process
*/
void acceptImage(ImageEvent image);
}
|
[
"[email protected]"
] | |
38d6658a24c0b5d0c26f80fb1bd1bb326c7064e7
|
19353d4e7cfd0b02448795c638f6d0b272731b3c
|
/6JavaConsole/src/program/RepeatingFilesRemover.java
|
2f1b6d5fdee1df4aa4bc6e1e717e2a539897713c
|
[] |
no_license
|
BohdanRomaniuk/Unix-Programming
|
a9d91ad9803baaabedfdfc2d20afd0dc63f91a4b
|
cba9f998e8579a02fa87dd787867a1d46c396143
|
refs/heads/master
| 2020-05-02T23:40:18.104059 | 2019-04-28T14:53:01 | 2019-04-28T14:53:01 | 178,286,851 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,652 |
java
|
package program;
import java.io.File;
public class RepeatingFilesRemover
{
private int removedCount;
public RepeatingFilesRemover()
{
removedCount = 0;
}
private String GetFileNameWithoutExtension(String fileName)
{
int dotPos = fileName.lastIndexOf(".");
return (dotPos!=-1) ? fileName.substring(0, dotPos) : fileName;
}
private String GetFileExtension(String fileName)
{
int dotPos = fileName.lastIndexOf(".");
return (dotPos!=-1) ? fileName.substring(dotPos) : fileName;
}
public static boolean FileExist(String path)
{
File file = new File(path);
return file.exists();
}
public int RemoveRepeatingFiles(String path, String allowedExt)
{
File folder = new File(path);
File[] files = folder.listFiles();
for (int i=0; i<files.length; ++i)
{
for(int j=i; j<files.length; ++j)
{
if (files[i].isFile() && files[j].isFile())
{
String fileName1 = GetFileNameWithoutExtension(files[i].getName());
String fileName2 = GetFileNameWithoutExtension(files[j].getName());
String ext1 = GetFileExtension(files[i].getName());
String ext2 = GetFileExtension(files[j].getName());
if(fileName1.equals(fileName2) && !ext1.equals(ext2))
{
if(!ext1.equals(allowedExt) && FileExist(files[i].getAbsolutePath()))
{
files[i].delete();
++removedCount;
}
if(!ext2.equals(allowedExt) && FileExist(files[j].getAbsolutePath()))
{
files[j].delete();
++removedCount;
}
}
}
}
}
return removedCount;
}
}
|
[
"[email protected]"
] | |
43a9c704cad901d2291bc0569930244b20d0f482
|
08095c4153c1ab3fcbba103759221b07e9ba5dce
|
/hello.java
|
c37ab8601e4f9b38eee5879b4e8bdcead5cf1c45
|
[] |
no_license
|
djoudihassane/f19
|
79e59d35b09c7d72abeb63d090f1be6e2fa4876e
|
3bb6d3cd72dd52240166a1a627d52f324da1dee3
|
refs/heads/master
| 2020-12-09T23:10:32.489573 | 2020-01-23T02:43:28 | 2020-01-23T02:43:28 | 233,442,317 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 121 |
java
|
public class Hello{
public static void main(String[] args)
{
System.out.println("hello word");
}
}
|
[
"[email protected]"
] | |
4364819e83304db00f8479a6f3004ce222bc5d13
|
9ac2299d5d6112d6f88ca996b641afa0f9484244
|
/src/main/java/com/jit/aquaculture/serviceimpl/daily/TypeListServiceImpl.java
|
a38ae07e4a47c540b802a4f1ff9615165aff5e8c
|
[] |
no_license
|
whxnuaa/aquaculture
|
9b037e54208b69bc9ee551e7d6c0ff40c745531e
|
e2097d167b31fc335c49582c2d5459b5561e84c1
|
refs/heads/master
| 2022-07-18T06:47:41.171706 | 2020-01-16T01:58:28 | 2020-01-16T01:58:28 | 233,971,453 | 1 | 0 | null | 2020-01-16T01:16:59 | 2020-01-15T01:29:47 |
Java
|
UTF-8
|
Java
| false | false | 4,638 |
java
|
package com.jit.aquaculture.serviceimpl.daily;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.type.TypeReference;
import com.jit.aquaculture.AquacultureApplication;
import com.jit.aquaculture.commons.util.JacksonUtils;
import com.jit.aquaculture.commons.util.ReadFileUtils;
import com.jit.aquaculture.config.iot.EquipType;
import com.jit.aquaculture.config.iot.SensorCmd;
import com.jit.aquaculture.config.iot.SensorValue;
import com.jit.aquaculture.serviceinterface.daily.TypeListService;
import org.apache.commons.io.FileUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Service;
import org.springframework.util.ResourceUtils;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
@Service
public class TypeListServiceImpl implements TypeListService {
private static StringBuilder all = new StringBuilder();
private JSONObject getJsonString(){
InputStream stream = getClass().getClassLoader().getResourceAsStream("/json/daily_type.json");
StringBuilder s = ReadFileUtils.readFileStream(stream);
JSONObject jsonObject = JSON.parseObject(s.toString());
return jsonObject;
}
@Override
public List<String> getFixedThrowName() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("fixed_throw").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getSeedName() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("seed_name").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getSeedBrand() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("seed_brand").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getFeedName() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("feed_name").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getFeedContent() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("feed_content").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getMedicineName() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("medicine_name").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getObserveName() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("observe_name").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getObserveContent() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("observe_content").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getBuyName() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("buy_name").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
@Override
public List<String> getSaleName() {
JSONObject jsonObject = getJsonString();
List<String> list = null;
String fixed = jsonObject.get("sale_name").toString();
list = JacksonUtils.readValue(fixed.toString(), new TypeReference<List<String>>() { });
return list;
}
}
|
[
"[email protected]"
] | |
66d4bb420f5f942390bdad79778ac13a6c27df5d
|
0fddaec8e389712107e99fb40a32903809416d7d
|
/plugins/org.jkiss.dbeaver.ui.editors.data/src/org/jkiss/dbeaver/ui/controls/resultset/virtual/VirtualAttributeDeleteAction.java
|
68708dae65bee319edec9f803e5adfd61c663b4c
|
[
"EPL-1.0",
"Apache-2.0",
"LGPL-2.0-or-later"
] |
permissive
|
kai-morich/dbeaver
|
83dce3057f510fe110380300c7eb51e5d5b5de21
|
0694ed136ddf089a5a01a0ceebd6e67585a7b2ee
|
refs/heads/devel
| 2022-02-19T00:07:03.733415 | 2022-02-11T14:35:37 | 2022-02-11T14:35:37 | 255,131,238 | 4 | 0 |
Apache-2.0
| 2020-04-12T17:08:35 | 2020-04-12T17:08:34 | null |
UTF-8
|
Java
| false | false | 2,255 |
java
|
/*
* DBeaver - Universal Database Manager
* Copyright (C) 2010-2022 DBeaver Corp and others
*
* 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.jkiss.dbeaver.ui.controls.resultset.virtual;
import org.eclipse.jface.action.Action;
import org.jkiss.dbeaver.model.data.DBDAttributeBinding;
import org.jkiss.dbeaver.model.data.DBDAttributeBindingCustom;
import org.jkiss.dbeaver.model.virtual.DBVEntity;
import org.jkiss.dbeaver.model.virtual.DBVEntityAttribute;
import org.jkiss.dbeaver.ui.UIUtils;
import org.jkiss.dbeaver.ui.controls.resultset.ResultSetViewer;
public class VirtualAttributeDeleteAction extends Action {
private ResultSetViewer resultSetViewer;
private DBDAttributeBinding attr;
public VirtualAttributeDeleteAction(ResultSetViewer resultSetViewer, DBDAttributeBinding attr) {
super("Delete virtual column '" + attr.getName() + "'");
this.resultSetViewer = resultSetViewer;
this.attr = attr;
}
@Override
public boolean isEnabled() {
return (attr instanceof DBDAttributeBindingCustom);
}
@Override
public void run() {
if (!(attr instanceof DBDAttributeBindingCustom)) {
return;
}
DBVEntityAttribute vAttr = ((DBDAttributeBindingCustom)attr).getEntityAttribute();
if (!UIUtils.confirmAction(resultSetViewer.getControl().getShell(), "Delete column '" + vAttr.getName() + "'", "Are you sure you want to delete virtual column '" + vAttr.getName() + "'?")) {
return;
}
DBVEntity vEntity = resultSetViewer.getModel().getVirtualEntity(false);
vEntity.removeVirtualAttribute(vAttr);
vEntity.persistConfiguration();
resultSetViewer.refreshMetaData();
}
}
|
[
"[email protected]"
] | |
abec64916c66a9a16d666832330aa447976c3fda
|
34d5d4c524aeeea322f94c32a5655091d4407f10
|
/app/src/main/java/com/asav/flexi/TimeBlockPage.java
|
4e5e3e60520ac6ff1e1f510a0f9b435c1c7fe6da
|
[] |
no_license
|
savardaaj/Flexii
|
33054f48829f6c5b3d865c09a9b50b5efc44e951
|
c1e226ce907d86240f82d05b9de6cd3eea1d0326
|
refs/heads/master
| 2020-04-17T13:48:43.482646 | 2019-01-20T06:41:17 | 2019-01-20T06:41:17 | 166,631,261 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 3,373 |
java
|
package com.asav.flexi;
import android.app.TimePickerDialog;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.TimePicker;
import java.util.Calendar;
public class TimeBlockPage extends AppCompatActivity {
DatabaseHandler dbh = new DatabaseHandler();
EditText et_name, et_description, et_startTime, et_endTime;
@Override
protected void onCreate(Bundle savedInstanceState) {
Log.d("***DEBUG***", "inside onCreate TimeBlockPage");
super.onCreate(savedInstanceState);
//setContentView(R.layout.activity_blockpage);
initializeLayout();
setupTimePickers();
}
public void initializeLayout() {
//et_name = findViewById(R.id.et_name);
}
public void setupTimePickers() {
Log.d("***DEBUG***", "inside initializeTimePickers");
et_startTime.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Calendar mcurrentTime = Calendar.getInstance();
int hour = mcurrentTime.get(Calendar.HOUR_OF_DAY);
int minute = mcurrentTime.get(Calendar.MINUTE);
TimePickerDialog mTimePicker;
mTimePicker = new TimePickerDialog(getApplicationContext(), new TimePickerDialog.OnTimeSetListener() {
@Override
public void onTimeSet(TimePicker timePicker, int selectedHour, int selectedMinute) {
et_startTime.setText( selectedHour + ":" + selectedMinute);
}
}, hour, minute, false);//No 24 hour time
mTimePicker.setTitle("Select Start Time");
mTimePicker.show();
}
});
et_endTime.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Calendar mcurrentTime = Calendar.getInstance();
int hour = mcurrentTime.get(Calendar.HOUR_OF_DAY);
int minute = mcurrentTime.get(Calendar.MINUTE);
TimePickerDialog mTimePicker;
mTimePicker = new TimePickerDialog(getApplicationContext(), new TimePickerDialog.OnTimeSetListener() {
@Override
public void onTimeSet(TimePicker timePicker, int selectedHour, int selectedMinute) {
et_endTime.setText( selectedHour + ":" + selectedMinute);
}
}, hour, minute, false);//No 24 hour time
mTimePicker.setTitle("Select Start Time");
mTimePicker.show();
}
});
}
public void onClickSaveBlockTime(View v) {
Log.d("***DEBUG***", "inside onClickSaveBlockTime");
TimeBlock timeblock = new TimeBlock();
timeblock.userId = "test123";
timeblock.name = et_name.getText().toString();
timeblock.description = et_description.getText().toString();
timeblock.startTime = et_startTime.getText().toString();
timeblock.endTime = et_endTime.getText().toString();
dbh.createTimeBlock(timeblock);
}
}
|
[
"[email protected]"
] | |
6d7dd0aaba34c74eafdb742ac1c805ca97bd8d1a
|
a9d53ad7cb2234432fe68b5141ca21e13707ecba
|
/src/com/practice/UglyNumber.java
|
78bdd2bd5c2b7e5261d28aa7672bfbc0c8a3baa9
|
[] |
no_license
|
LearnAndShare/interview
|
f605ad1dcba0b5d99764e25813357e6afe5bfb05
|
9341bca9daff34ae44cd4563e07e30a949d82251
|
refs/heads/master
| 2021-07-08T12:51:16.515587 | 2020-09-13T00:19:00 | 2020-09-13T00:19:00 | 189,089,156 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,297 |
java
|
package com.practice;
/*
https://leetcode.com/problems/ugly-number-ii/
Ugly numbers are positive numbers whose prime factors only include 2, 3, 5.
Example:
Input: n = 10
Output: 12
Explanation: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 is the sequence of the first 10 ugly numbers.
*/
public class UglyNumber {
public int nthUglyNumber(int n) {
if(n<=0)
return 0;
if(n ==1 )
return 1;
int[] n1 = new int[n];
n1[0] = 1;
int i2=0,i3=0,i5=0;
int i2_next = 2;
int i3_next = 3;
int i5_next = 5;
for(int i=1;i<n;i++){
int num = Math.min(i2_next,Math.min(i3_next,i5_next));
n1[i] = num;
System.out.println("Next ugly num::"+num);
if(num == i2_next){
i2++;
i2_next = n1[i2]*2;
}
if(num == i3_next){
i3++;
i3_next = n1[i3]*3;
}
if(num == i5_next){
i5++;
i5_next =n1[i5]*5;
}
}
return n1[n-1];
}
public static void main(String[] args) {
UglyNumber un = new UglyNumber();
System.out.println(un.nthUglyNumber(1));
System.out.println(un.nthUglyNumber(10));
}
}
|
[
"[email protected]"
] | |
40da8b7b9cb3971606dc7ac38c95a6a152c97fdb
|
0d40a80471a133f2272752ca0a4aac0ab76a2933
|
/SistemaCatalogoAplicacionesYanbal1/src/com/yanbal/catalogo/controller/SubProcesoNegocioController.java
|
d53c1f783596beea1db0084a227208979daa05c8
|
[] |
no_license
|
jmezaldi/CataD0
|
40bcf81f137369bc2f61e128979f13632d7727d0
|
d18fb6e3a09e49203880240c4e2fb6321bd11532
|
refs/heads/master
| 2021-01-10T09:55:00.909829 | 2016-04-27T22:57:34 | 2016-04-27T22:57:34 | 50,673,694 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 8,587 |
java
|
package com.yanbal.catalogo.controller;
import com.yanbal.catalogo.bean.BaseDatos;
import com.yanbal.catalogo.bean.SubProcesoNegocio;
import com.yanbal.catalogo.controller.util.JsfUtil;
import com.yanbal.catalogo.controller.util.PaginationHelper;
import com.yanbal.catalogo.ejb.SubProcesoNegocioFacade;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
import javax.faces.convert.FacesConverter;
import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;
import javax.faces.model.SelectItem;
@ManagedBean(name = "subProcesoNegocioController")
@SessionScoped
public class SubProcesoNegocioController implements Serializable {
private SubProcesoNegocio current;
private DataModel items = null;
@EJB
private com.yanbal.catalogo.ejb.SubProcesoNegocioFacade ejbFacade;
@EJB
private com.yanbal.catalogo.ejb.UsuarioFacade ejbFacadeUsuario;
private PaginationHelper pagination;
private int selectedItemIndex;
private List<SubProcesoNegocio> filteredItems;
UtilController util = new UtilController();
private FacesContext fCtx;
public SubProcesoNegocioController() {
}
public SubProcesoNegocio getSelected() {
if (current == null) {
current = new SubProcesoNegocio();
selectedItemIndex = -1;
}
return current;
}
private SubProcesoNegocioFacade getFacade() {
return ejbFacade;
}
public PaginationHelper getPagination() {
if (pagination == null) {
pagination = new PaginationHelper(10000) {
@Override
public int getItemsCount() {
return getFacade().count();
}
@Override
public DataModel createPageDataModel() {
return new ListDataModel(getFacade().findRange(
new int[] { getPageFirstItem(),
getPageFirstItem() + getPageSize() }));
}
};
}
return pagination;
}
public String prepareList() {
recreateModel();
return "List";
}
public String prepareView() {
current = (SubProcesoNegocio) getItems().getRowData();
selectedItemIndex = pagination.getPageFirstItem()
+ getItems().getRowIndex();
return "View";
}
public String prepareCreate() {
current = new SubProcesoNegocio();
selectedItemIndex = -1;
return "Create";
}
public String create() {
fCtx = FacesContext.getCurrentInstance();
Map<String, String> reqMap = fCtx.getExternalContext()
.getRequestParameterMap();
String email = (String) reqMap.get("email_account");
try {
getFacade().create(current);
JsfUtil.addSuccessMessage(ResourceBundle.getBundle("/Bundle")
.getString("SubProcesoNegocioCreated"));
util.sendEmailAccounts(email,ejbFacadeUsuario.findAll(),
ResourceBundle.getBundle("/Bundle").getString("ADD")
+ current.getId() + " - " + current.getNombre(),
ResourceBundle.getBundle("/Bundle").getString("EVENTO_ADD"));
return prepareCreate();
} catch (Exception e) {
JsfUtil.addErrorMessage(e, ResourceBundle.getBundle("/Bundle")
.getString("PersistenceErrorOccured"));
return null;
}
}
public String prepareEdit() {
current = (SubProcesoNegocio) getItems().getRowData();
selectedItemIndex = pagination.getPageFirstItem()
+ getItems().getRowIndex();
return "Edit";
}
public String update() {
fCtx = FacesContext.getCurrentInstance();
Map<String, String> reqMap = fCtx.getExternalContext()
.getRequestParameterMap();
String email = (String) reqMap.get("email_account");
try {
getFacade().edit(current);
JsfUtil.addSuccessMessage(ResourceBundle.getBundle("/Bundle")
.getString("SubProcesoNegocioUpdated"));
util.sendEmailAccounts(email,ejbFacadeUsuario.findAll(),
ResourceBundle.getBundle("/Bundle").getString("EDIT")
+ current.getId() + " - " + current.getNombre(),
ResourceBundle.getBundle("/Bundle")
.getString("EVENTO_EDIT"));
return "View";
} catch (Exception e) {
JsfUtil.addErrorMessage(e, ResourceBundle.getBundle("/Bundle")
.getString("PersistenceErrorOccured"));
return null;
}
}
public String destroy() {
current = (SubProcesoNegocio) getItems().getRowData();
selectedItemIndex = pagination.getPageFirstItem()
+ getItems().getRowIndex();
performDestroy();
recreateModel();
return "List";
}
public String destroyAndView() {
performDestroy();
recreateModel();
updateCurrentItem();
if (selectedItemIndex >= 0) {
return "View";
} else {
// all items were removed - go back to list
recreateModel();
return "List";
}
}
private void performDestroy() {
fCtx = FacesContext.getCurrentInstance();
Map<String, String> reqMap = fCtx.getExternalContext().getRequestParameterMap();
String email = (String) reqMap.get("email_account");
try {
getFacade().remove(current);
JsfUtil.addSuccessMessage(ResourceBundle.getBundle("/Bundle")
.getString("SubProcesoNegocioDeleted"));
util.sendEmailAccounts(email,ejbFacadeUsuario.findAll(),
ResourceBundle.getBundle("/Bundle").getString("DELETE")
+ current.getId() + " - " + current.getNombre(),
ResourceBundle.getBundle("/Bundle").getString("EVENTO_DELETE"));
} catch (Exception e) {
JsfUtil.addErrorMessage(e, ResourceBundle.getBundle("/Bundle")
.getString("PersistenceErrorOccured"));
}
}
private void updateCurrentItem() {
int count = getFacade().count();
if (selectedItemIndex >= count) {
// selected index cannot be bigger than number of items:
selectedItemIndex = count - 1;
// go to previous page if last page disappeared:
if (pagination.getPageFirstItem() >= count) {
pagination.previousPage();
}
}
if (selectedItemIndex >= 0) {
current = getFacade().findRange(
new int[] { selectedItemIndex, selectedItemIndex + 1 })
.get(0);
}
}
public DataModel getItems() {
if (items == null) {
items = getPagination().createPageDataModel();
filteredItems = new ArrayList<SubProcesoNegocio>(
ejbFacade.findAll());
}
return items;
}
private void recreateModel() {
items = null;
}
public String next() {
getPagination().nextPage();
recreateModel();
return "List";
}
public String previous() {
getPagination().previousPage();
recreateModel();
return "List";
}
public SelectItem[] getItemsAvailableSelectMany() {
return JsfUtil.getSelectItems(ejbFacade.findAll(), false);
}
public SelectItem[] getItemsAvailableSelectOne() {
return JsfUtil.getSelectItems(ejbFacade.findAll(), true);
}
@FacesConverter(forClass = SubProcesoNegocio.class)
public static class SubProcesoNegocioControllerConverter implements
Converter {
public Object getAsObject(FacesContext facesContext,
UIComponent component, String value) {
if (value == null || value.length() == 0) {
return null;
}
SubProcesoNegocioController controller = (SubProcesoNegocioController) facesContext
.getApplication()
.getELResolver()
.getValue(facesContext.getELContext(), null,
"subProcesoNegocioController");
return controller.ejbFacade.find(getKey(value));
}
java.lang.Long getKey(String value) {
java.lang.Long key;
key = Long.valueOf(value);
return key;
}
String getStringKey(java.lang.Long value) {
StringBuffer sb = new StringBuffer();
sb.append(value);
return sb.toString();
}
public String getAsString(FacesContext facesContext,
UIComponent component, Object object) {
if (object == null) {
return null;
}
if (object instanceof SubProcesoNegocio) {
SubProcesoNegocio o = (SubProcesoNegocio) object;
return getStringKey(o.getId());
} else {
throw new IllegalArgumentException("object " + object
+ " is of type " + object.getClass().getName()
+ "; expected type: "
+ SubProcesoNegocioController.class.getName());
}
}
}
public String prepareEditCust(SubProcesoNegocio obj) {
current = obj;
selectedItemIndex = pagination.getPageFirstItem()
+ getItems().getRowIndex();
return "Edit";
}
public String destroyCust(SubProcesoNegocio obj) {
current = obj;
selectedItemIndex = pagination.getPageFirstItem()
+ getItems().getRowIndex();
performDestroy();
recreateModel();
return "List";
}
public List<SubProcesoNegocio> getFilteredItems() {
return filteredItems;
}
public void setFilteredItems(List<SubProcesoNegocio> filteredItems) {
this.filteredItems = filteredItems;
}
}
|
[
"[email protected]"
] | |
bcc786405eba38504cc141b63825e3503876bc69
|
41ccb5df308180830ca0560fd9deef1ec6101894
|
/src/br/unisul/prolinear/core/simplex/solver/SimplexSolver.java
|
65a2278c6daa8efaa735e5f621f8c05532e77c30
|
[] |
no_license
|
angelosilvestre/prolinear-core
|
f82c7a754822b47b9be16134483c2ddcb004ba82
|
a3094379f6b3c0c629879ea883a9110569fc2829
|
refs/heads/master
| 2020-02-26T14:54:45.884923 | 2014-06-19T16:18:09 | 2014-06-19T16:18:09 | null | 0 | 0 | null | null | null | null |
ISO-8859-1
|
Java
| false | false | 13,953 |
java
|
package br.unisul.prolinear.core.simplex.solver;
import java.io.StringReader;
import java.util.ArrayList;
import org.nfunk.jep.JEP;
import org.nfunk.jep.Node;
import br.unisul.prolinear.core.compilador.AnalisadorLexico;
import br.unisul.prolinear.core.compilador.AnalisadorSemantico;
import br.unisul.prolinear.core.compilador.AnalisadorSintatico;
import br.unisul.prolinear.core.compilador.LexicalError;
import br.unisul.prolinear.core.compilador.SemanticError;
import br.unisul.prolinear.core.compilador.SyntaticError;
import br.unisul.prolinear.core.exceptions.InfeasibleModelException;
import br.unisul.prolinear.core.exceptions.UnboundedModelException;
import br.unisul.prolinear.core.simplex.equacao.CampoCalculado;
import br.unisul.prolinear.core.simplex.equacao.Equacao;
import br.unisul.prolinear.core.simplex.equacao.Equacao.SinalEquacao;
import br.unisul.prolinear.core.simplex.equacao.FuncaoObjetivo;
import br.unisul.prolinear.core.simplex.equacao.Restricao;
import br.unisul.prolinear.core.simplex.equacao.Variavel;
import br.unisul.prolinear.core.simplex.equacao.Variavel.TipoVariavel;
import br.unisul.prolinear.core.simplex.solver.Problema.TipoProblema;
@SuppressWarnings("unchecked")
public class SimplexSolver {
Problema problema;
FuncaoObjetivo objetivoPrimeiraFase;
boolean primeiraFase;
private boolean dualSimplex;
private int iteracoes;
private Solucao melhorSolucao;
public Solucao solve(String modelo) throws UnboundedModelException, InfeasibleModelException, LexicalError, SyntaticError, SemanticError{
AnalisadorLexico lexico = new AnalisadorLexico();
AnalisadorSintatico sintatico = new AnalisadorSintatico();
AnalisadorSemantico semantico = new AnalisadorSemantico();
lexico.setInput(new StringReader(modelo.toUpperCase()));
sintatico.parse(lexico, semantico);
return solve(semantico.getP());
}
public Solucao solve(Problema p) throws InfeasibleModelException, SyntaticError, UnboundedModelException{
primeiraFase = false;
dualSimplex = false;
iteracoes = 0;
problema = p;
if(p.getTipo() == TipoProblema.MAX){
p.getFuncao().multiplicar(-1);
}
adicionaVariaveisFolga();
if(dualSimplex){
fase1();
}
while(!solucaoOtimaEncontrada()){
//if(iteracoes > 1000) throw new UnboundedModelException("Não foi possível resolver este problema, entre em contato com o desenvolvimento e informe o problema ocorrido");
iteracoes++;
recalculaValores();
}
if(p.getTipo() == TipoProblema.MIN){
p.getFuncao().multiplicar(-1);
}
Solucao s = new Solucao(p);
for(Restricao r : p.getRestricoes()){
s.getResultSet().put(r.getVariavelBasica(), r.getValorEquacaoTableau());
}
s.setValorOtimo(problema.getFuncao().getValorEquacaoTableau());
s = branchAndBound(s);
s.setIteracoes(iteracoes);
for(Restricao r : p.getRestricoes()){
Variavel var = r.getVariavelFolga();
Double folga = s.getResultSet().get(var);
if((folga != null) && (SimplexUtils.round(folga, p.getCasasDecimais()) > 0)){
p.setFolga(true);
r.setFolga(folga);
Double conversao = r.getConversao();
if(conversao != null){
folga = SimplexUtils.round(conversao * (int)(folga / conversao),p.getCasasDecimais());
}
r.setValorOtimizado(r.getValorEquacaoOriginal() - (r.getSinal() == Equacao.SinalEquacao.MenorIgual ? folga : -folga));
}
}
for(CampoCalculado c : p.getCamposCalculados()){
JEP j = new JEP();
String expressao = " " +c.getExpressao() + " ";
expressao = expressao
.replace("+", " + ")
.replace("-", " - ")
.replace("*", " * ")
.replace("/", " / ")
.replace("^", " ^ ")
.replace("(", " ( ")
.replace(")", " ) ");
try{
for(Variavel v: p.getVariaveis()){
if(expressao.indexOf(" "+v.getNome()+" ") > -1){
expressao = expressao.replace(" " +v.getNome()+ " ", s.getValorVariavel(v)+"");
}
}
for(CampoCalculado campo: p.getCamposCalculados()){
if(expressao.indexOf(campo.getNome()) > -1){
expressao = expressao.replace(" " +campo.getNome()+ " ",s.getValorVariavel(campo)+"");
}
}
Node n = j.parse(expressao);
Double valor = (Double)j.evaluate(n);
s.getResultSet().put(c, valor);
}catch (Exception e) {
throw new SyntaticError("Erro resolvendo campos calculados");
}
}
return s;
}
private boolean solucaoOtimaEncontrada(){
FuncaoObjetivo f;
if(!primeiraFase)
f = problema.getFuncao();
else
f = objetivoPrimeiraFase;
for(Variavel v:f.getVariaveisTableau()){
double coef = getCoeficienteObjetivo(f,v);
if(coef < 0)return false;
}
return true;
}
private void adicionaVariavelFolgaOuArificial(Restricao r,boolean folga, int numero){
Variavel v = new Variavel((folga ? "$F":"$A")+numero,folga ? TipoVariavel.FOLGA : TipoVariavel.ARTIFICIAL);
double valor = 1.0;
double valorObjetivo = 0.0;
if(folga){
if(r.getSinal() != SinalEquacao.MenorIgual) {
valor *= -1;
}
problema.getVariaveisFolga().add(v);
} else {
dualSimplex = true;
problema.getVariaveisArtificiais().add(v);
valorObjetivo = 0;
}
r.setVariavelBasica(v);
r.adicionaVariavel(v);
if(folga){
r.setVariavelFolga(v);
}
r.setaVariavel(v, valor);
problema.getFuncao().adicionaVariavel(v);
problema.getFuncao().setaVariavel(v, valorObjetivo);
}
private void fase1() throws InfeasibleModelException{
primeiraFase = true;
Restricao aux = null;
for(Variavel v: problema.getVariaveisArtificiais()){
if(aux == null){
aux = getRestricao(v).clone();
}else{
aux.somar(getRestricao(v));
}
aux.setaVariavel(v,0.0);
}
aux.multiplicar(-1);
objetivoPrimeiraFase = new FuncaoObjetivo();
for(Variavel v: aux.getVariaveisTableau()){
// for(Variavel v:aux.getVariaveisOriginais()){
objetivoPrimeiraFase.adicionaVariavel(v);
objetivoPrimeiraFase.setaVariavel(v, aux.getCoeficientesTableau().get(v));
}
objetivoPrimeiraFase.setValorEquacaoTableau(aux.getValorEquacaoTableau());
problema.setObjetivoPrimeiraFase(objetivoPrimeiraFase);
while(!solucaoOtimaEncontrada()){
iteracoes++;
recalculaValores();
}
for(Variavel v: problema.getVariaveisArtificiais()){
System.out.println(objetivoPrimeiraFase.getCoeficientesTableau().get(v));
for(Restricao r : problema.getRestricoes()){
if(r.getVariavelBasica().getTipo() == TipoVariavel.ARTIFICIAL)
throw new InfeasibleModelException("O problema não possui solução viável.");
if(r.getVariaveisTableau().contains(v)){
r.getVariaveisTableau().remove(v);
r.getCoeficientesTableau().remove(v);
}
}
if(problema.getFuncao().getVariaveisTableau().contains(v)){
problema.getFuncao().getVariaveisTableau().remove(v);
problema.getFuncao().getCoeficientesTableau().remove(v);
}
v = null;
}
problema.setVariaveisArtificiais(new ArrayList<Variavel>());
problema.setObjetivoPrimeiraFase(null);
System.out.println(problema);
objetivoPrimeiraFase = null;
primeiraFase = false;
System.out.println("Iniciando Fase 2");
}
private void adicionaVariaveisFolga(){
problema.setVariaveis((ArrayList<Variavel>) problema.getFuncao().getVariaveisTableau().clone());
int variaveisFolga =0;
int variaveisArtificiais = 0;
for(Restricao r: problema.getRestricoes()){
/* se for uma inequação é necessário adicionar uma variável de folga
e transformá-la numa equação */
if(r.getSinal() != SinalEquacao.Igual){
variaveisFolga++;
adicionaVariavelFolgaOuArificial(r, true, variaveisFolga);
}
/*
* Quando o sinal for diferente de menor igual
* é necessário incluir variáveis artificiais
*/
if(r.getSinal() != SinalEquacao.MenorIgual){
variaveisArtificiais++;
adicionaVariavelFolgaOuArificial(r, false, variaveisArtificiais);
}
}
/*
* adiciona os coeficientes de todas as variáveis do problema
* para cada restrição, para a construção do tableau
*/
for(Variavel var:problema.getFuncao().getVariaveisTableau()){
for(Restricao r:problema.getRestricoes()){
if(!r.getVariaveisTableau().contains(var)){
r.adicionaVariavel(var);
r.setaVariavel(var, 0.0);
}
}
}
}
private Restricao getRestricao(Variavel basica){
for(Restricao r: problema.getRestricoes()){
if(r.getVariavelBasica().equals(basica)) return r;
}
return null;
}
public Double getNumeroPivo(Variavel t, Restricao r){
return r.getCoeficientesTableau().get(t);
}
/***
* Recalcula os valores do tableau
*/
private void recalculaValores(){
FuncaoObjetivo f ;
if(!primeiraFase){
f = problema.getFuncao();
}else{
f = objetivoPrimeiraFase;
}
Variavel colunaPivo = getColunaPivo();
System.out.println("\nColuna Pivô : " + colunaPivo+"\n");
Restricao linhaPivo = getLinhaPivo(colunaPivo);
System.out.println("\nLinha Pivô : " + linhaPivo+"\n");
double numeroPivo = getNumeroPivo(colunaPivo, linhaPivo);
linhaPivo.dividir(numeroPivo);
linhaPivo.setVariavelBasica(colunaPivo);
Equacao linhaPivoModificada = linhaPivo.clone();
linhaPivoModificada.multiplicar(getCoeficienteObjetivo(f,colunaPivo));
f.subtrair(linhaPivoModificada);
if(f != problema.getFuncao()){
linhaPivoModificada = linhaPivo.clone();
linhaPivoModificada.multiplicar(getCoeficienteObjetivo(problema.getFuncao(), colunaPivo));
problema.getFuncao().subtrair(linhaPivoModificada);
}
/*para cada restrição calcula a linha pivo modificada
e recalcula os valores does coeficientes*/
for(Restricao r: problema.getRestricoes()){
if(r != linhaPivo){
linhaPivoModificada = linhaPivo.clone();
linhaPivoModificada.multiplicar(getCoeficienteRestricao(r, colunaPivo));
r.subtrair(linhaPivoModificada);
}
}
}
/***
* Busca o coeficiente de uma variavel na função objetivo
* @param t Termo a ser buscado o coeficiente
* @return o coeficiente do termo t
*/
private double getCoeficienteObjetivo(FuncaoObjetivo f, Variavel v){
return f.getCoeficientesTableau().get(v);
}
/**
* Busca o coeficiente de uma variável em uma restrição
* @param r Restrição que contém a variável
* @param v Variável a ser buscado o termo
* @return Valor do coeficiente
*/
private double getCoeficienteRestricao(Restricao r, Variavel v){
return r.getCoeficientesTableau().get(v);
}
/***
*
* @return Coluna que será base para os cálculos do tableau
*/
private Variavel getColunaPivo(){
FuncaoObjetivo f;
if(primeiraFase){
f = objetivoPrimeiraFase;
}else {
f = problema.getFuncao();
}
Variavel pivo = null;//problema.getVariaveis().get(0);
boolean positivos = true;
double min = Double.MAX_VALUE;
for(Variavel v: f.getVariaveisTableau()){
double valor = getCoeficienteObjetivo(f, v);
if(valor < min){
pivo = v;
min = valor;
}
if(valor < 0) positivos = false;
}
return positivos ? null : pivo;
}
private Restricao getLinhaPivo(Variavel pivo){
Restricao linhaPivo = null;// problema.getRestricoes().get(0);
double minimo = Double.MAX_VALUE;
double aux = 0;
for(Restricao r: problema.getRestricoes()){
double coeficiente = getCoeficienteRestricao(r, pivo);
if(coeficiente > 0){
aux = r.getValorEquacaoTableau() / coeficiente;
if(aux <= minimo){
minimo = aux;
linhaPivo = r;
}
}
}
return linhaPivo;
}
/***
*
* @param p Problema a ser resolvido
* @return Um objeto da classe solução, que representa a solução ótima do problema
*/
private Solucao branchAndBound(Solucao s){
Variavel v;
while((v = variavelSeparacao(s)) != null){
iteracoes++;
double valor = s.getValorVariavel(v);
int valorSuperior = (int)(valor + 1);
int valorInferior = (int) valor;
Solucao solucaoSuperior = null;
Solucao solucaoInferior = null;
Problema problemaSuperior = s.getProblema().getCleanCopy();
problemaSuperior.removeUltimaRestricaoArtificial(v);
Restricao r = new Restricao();
r.adicionaVariavelOriginal(v);
r.setaVariavelOriginal(v, 1.0);
r.setSinal(SinalEquacao.MaiorIgual);
r.setValorEquacaoOriginal((double) valorSuperior);
r.setArtificial(true);
problemaSuperior.getRestricoes().add(r);
Solucao candidata = null;
SimplexSolver solverBranchAndBound = new SimplexSolver();
try {
solucaoSuperior = solverBranchAndBound.solve(problemaSuperior);
} catch (Exception e) {
}
//solucaoSuperior = solverBranchAndBound.branchAndBound(s);
Problema problemaInferior = s.getProblema().getCleanCopy();
problemaInferior.removeUltimaRestricaoArtificial(v);
r = new Restricao();
r.adicionaVariavelOriginal(v);
r.setaVariavelOriginal(v, 1.0);
r.setSinal(SinalEquacao.MenorIgual);
r.setValorEquacaoOriginal((double)valorInferior);
r.setArtificial(true);
problemaInferior.getRestricoes().add(r);
try {
solucaoInferior = solverBranchAndBound.solve(problemaInferior);
} catch (Exception e) {
}
//solucaoInferior = solverBranchAndBound.branchAndBound(candidata);
candidata = melhorSolucaoInteira(solucaoSuperior,solucaoInferior);
if(candidata != null){
melhorSolucao = melhorSolucaoInteira(melhorSolucao,candidata);
s = melhorSolucao;
}
}
melhorSolucao = melhorSolucaoInteira(s, melhorSolucao);
s.getProblema().melhorSolucao = melhorSolucao;
return melhorSolucao;
}
private Solucao melhorSolucaoInteira(Solucao s1, Solucao s2){
if(s1 == null){
return s2;
}else if(s2 == null){
return s1;
} else{
return s1.melhorSolucaoInteiraQue(s2) ? s1: s2;
}
}
private Variavel variavelSeparacao(Solucao s){
Variavel sep = null;
double valorMaximo = 0;
for(Variavel v: problema.getVariaveis()){
if(v.isInteira()){
Double valor = s.getValorVariavel(v);
if(valor != null && SimplexUtils.round(valor,problema.getCasasDecimais()) % 1 !=0 && valor > valorMaximo){
sep = v;
valorMaximo = valor;
}
}
}
return sep;
}
}
|
[
"[email protected]"
] | |
bdc49fd63c1c3e0c2d7e8fc1a4cbfbcc4b73e8c5
|
8b5bad5ef44808a1a5abe4bbafd7a763c3d2c9b6
|
/web-project/src/main/java/blooming/webproject/controller/RegisterController.java
|
82bcd17fdb85337412c7fca4c1ae2da695b80313
|
[] |
no_license
|
aksel26/react_temPrj
|
59b65d829932ed35fb856e047f295caa0766f7d6
|
c02c80dd39b783c3825bdae9a148ca29b98f249e
|
refs/heads/master
| 2023-04-21T13:01:47.231288 | 2021-04-26T10:43:39 | 2021-04-26T10:43:39 | 349,807,189 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 77 |
java
|
package blooming.webproject.controller;
public class RegisterController {
}
|
[
"[email protected]"
] | |
649a67fa4f03ddbc6bd32134500e52cd9b0a2c85
|
18d47c6761d7b5ff298aa550ba73113d724531b2
|
/firstdemo/src/com/neuedu/api/object0728/three/Goods.java
|
fddcbb538c7a26f04c3e1ca7ace79cce07555d26
|
[] |
no_license
|
jeaniely/taili204
|
135c04c78ab20e407b6ad44b57f00098e2501067
|
68c8e1f42f4e84918b7c11c6d5d6e726ab754cb1
|
refs/heads/master
| 2022-12-04T10:22:55.383875 | 2020-08-17T04:52:04 | 2020-08-17T04:52:04 | 288,086,255 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 803 |
java
|
package com.neuedu.api.object0728.three;
import java.math.BigDecimal;
public class Goods {
private String name;
private BigDecimal price;
private Integer stock;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public BigDecimal getPrice() {
return price;
}
public void setPrice(BigDecimal price) {
this.price = price;
}
public Integer getStock() {
return stock;
}
public void setStock(Integer stock) {
this.stock = stock;
}
@Override
public String toString() {
return "Goods{" +
"name='" + name + '\'' +
", price=" + price +
", stock=" + stock +
'}';
}
}
|
[
"[email protected]"
] | |
c9a6e6d7f2a69acb243c5815ca2c4866167a99d5
|
a6a6fb681bc0222e16454bb3ddb79696e6ea1ad5
|
/disassembly_2020-07-06/sources/com/samsung/android/sdk/cover/LegacyLedSystemEventListenerDelegate.java
|
c5d8d9cd0a234d2728a897c99bb98337f6fc2320
|
[] |
no_license
|
ThePBone/GalaxyBudsLive-Disassembly
|
6f9c1bf03c0fd27689dcc2440f754039ac54b7a1
|
ad119a91b20904f8efccc797f3084005811934c8
|
refs/heads/master
| 2022-11-23T13:20:54.555338 | 2020-07-28T21:33:30 | 2020-07-28T21:33:30 | 282,281,940 | 3 | 2 | null | null | null | null |
UTF-8
|
Java
| false | false | 4,158 |
java
|
package com.samsung.android.sdk.cover;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;
import com.samsung.android.cover.INfcLedCoverTouchListenerCallback;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
class LegacyLedSystemEventListenerDelegate extends INfcLedCoverTouchListenerCallback.Stub {
private static final int MSG_SYSTEM_COVER_EVENT = 0;
private static final String SYSTEM_EVENT_LED_OFF_COMMAND = "led_off_command";
/* access modifiers changed from: private */
public static final String TAG = LegacyLedSystemEventListenerDelegate.class.getSimpleName();
private ListenerDelegateHandler mHandler;
private Object mListener;
public void onCoverTouchAccept() throws RemoteException {
}
public void onCoverTouchReject() throws RemoteException {
}
LegacyLedSystemEventListenerDelegate(Object obj, Handler handler, Context context) {
this.mListener = obj;
this.mHandler = new ListenerDelegateHandler(handler == null ? context.getMainLooper() : handler.getLooper(), this.mListener);
}
public Object getListener() {
return this.mListener;
}
public void onSystemCoverEvent(int i, int[] iArr) throws RemoteException {
Message obtainMessage = this.mHandler.obtainMessage(0);
obtainMessage.arg1 = i;
obtainMessage.obj = iArr;
obtainMessage.sendToTarget();
}
private static class ListenerDelegateHandler extends Handler {
private final Object mListener;
public ListenerDelegateHandler(Looper looper, Object obj) {
super(looper);
this.mListener = obj;
}
public void handleMessage(Message message) {
if (this.mListener != null && message.what == 0) {
int[] iArr = (int[]) message.obj;
Method method = null;
try {
method = this.mListener.getClass().getMethod("onSystemCoverEvent", new Class[]{Integer.TYPE, Bundle.class});
} catch (SecurityException e) {
Log.e(LegacyLedSystemEventListenerDelegate.TAG, "Error getting onSystemCoverEvent method", e);
} catch (NoSuchMethodException e2) {
Log.e(LegacyLedSystemEventListenerDelegate.TAG, "Error getting onSystemCoverEvent method", e2);
}
if (method != null) {
if (iArr != null) {
try {
if (iArr.length >= 1) {
Bundle bundle = new Bundle();
bundle.putInt(LegacyLedSystemEventListenerDelegate.SYSTEM_EVENT_LED_OFF_COMMAND, iArr[0]);
method.invoke(this.mListener, new Object[]{Integer.valueOf(message.arg1), bundle});
return;
}
} catch (IllegalAccessException e3) {
String access$000 = LegacyLedSystemEventListenerDelegate.TAG;
Log.e(access$000, "Error invoking " + method.getName(), e3);
return;
} catch (IllegalArgumentException e4) {
String access$0002 = LegacyLedSystemEventListenerDelegate.TAG;
Log.e(access$0002, "Error invoking " + method.getName(), e4);
return;
} catch (InvocationTargetException e5) {
String access$0003 = LegacyLedSystemEventListenerDelegate.TAG;
Log.e(access$0003, "Error invoking " + method.getName(), e5);
return;
}
}
String access$0004 = LegacyLedSystemEventListenerDelegate.TAG;
Log.e(access$0004, "Error: system event args empty: " + iArr);
}
}
}
}
}
|
[
"[email protected]"
] | |
b94bcaffcd22918ba87e53c88acb68a725ac8b14
|
f27f09e4b4b2302e33b84417a16fbb5c698b1cdc
|
/gwtent/src/main/java/com/gwtent/reflection/client/annotations/Reflect_SubClasses.java
|
0e6ef6261b283e03cba7508b0258a9b9bde7a8ab
|
[
"Apache-2.0"
] |
permissive
|
nikelin/gwtent
|
f24b63fb49c698d561cca12bf83e72ee61dad7f8
|
e42ac106ad1b51e5d9764a86f9a9588c2a289410
|
refs/heads/master
| 2020-04-19T10:18:50.905010 | 2014-09-12T15:24:58 | 2014-09-12T15:24:59 | 23,965,815 | 2 | 3 | null | null | null | null |
UTF-8
|
Java
| false | false | 545 |
java
|
package com.gwtent.reflection.client.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.gwtent.reflection.client.Reflectable;
/**
* Just sub classes, limit to without relationTypes
*
* @author [email protected]
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Reflectable(relationTypes=false, superClasses=false, assignableClasses=true)
public @interface Reflect_SubClasses {
}
|
[
"[email protected]"
] | |
07ff690dc1a3337ccdba1f7b4992627b5c48834f
|
8f11bb9c5295d1786ecb6399c0fa62f021eb8d63
|
/ppmtool/src/main/java/akhilyerabati/ppmtool/security/SecurityConstants.java
|
63a290cc00b157433cc87d93e44c71646804a55c
|
[] |
no_license
|
yerabatiakhil/PPMTOOL
|
044017e92b270e5f27c8079fbc61466f8fef34dc
|
555f7223e7eba0d4f15fbfc82da5a237250d47a7
|
refs/heads/master
| 2023-01-11T15:03:51.179866 | 2019-08-20T20:52:35 | 2019-08-20T20:52:35 | 200,904,852 | 0 | 0 | null | 2023-01-04T07:01:56 | 2019-08-06T18:34:29 |
JavaScript
|
UTF-8
|
Java
| false | false | 447 |
java
|
package akhilyerabati.ppmtool.security;
public class SecurityConstants {
public static final String SIGN_UP_URLS = "/api/users/**";
public static final String H2_URL = "h2-console/**";
public static final String SECRET ="SecretKeyToGenJWTs";
public static final String TOKEN_PREFIX= "Bearer ";
public static final String HEADER_STRING = "Authorization";
public static final long EXPIRATION_TIME = 300_000; //30 seconds
}
|
[
"[email protected]"
] | |
d91acee901dd4b0bab5bbee86f7f7f457f8d96d1
|
f0f2415e1f19a9e6ed66c7ddaef9350e99e7b775
|
/trunk/src/main/java/dayan/eve/web/dto/HotSchoolReadDTO.java
|
42531d7bbb1d1730919a6c6c068ba2c17135094c
|
[] |
no_license
|
x472622902/eve
|
faa77018fdae91522a0fbf0d1c8720033623f8f6
|
401efc66ba0b6523f722f9e89bf5a2b1d538d9b8
|
refs/heads/master
| 2021-01-12T05:00:05.901807 | 2017-06-12T08:48:57 | 2017-06-12T08:48:57 | 77,828,220 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,059 |
java
|
/**
* *****************************************************
* Copyright (C) Dayan techology Co.ltd - All Rights Reserved
* <p>
* This file is part of Dayan techology Co.ltd property.
* <p>
* Unauthorized copying of this file, via any medium is strictly prohibited
* Proprietary and confidential
* *****************************************************
*/
package dayan.eve.web.dto;
import dayan.eve.model.Pager;
import dayan.eve.model.school.HotSchoolGroup;
/**
* @author xsg
*/
public class HotSchoolReadDTO {
private HotSchoolGroup schools;
private Pager pager;
public HotSchoolReadDTO() {
}
public HotSchoolReadDTO(HotSchoolGroup schools, Pager pager) {
this.schools = schools;
this.pager = pager;
}
public Pager getPager() {
return pager;
}
public void setPager(Pager pager) {
this.pager = pager;
}
public HotSchoolGroup getSchools() {
return schools;
}
public void setSchools(HotSchoolGroup schools) {
this.schools = schools;
}
}
|
[
"[email protected]"
] | |
30e7e85c695f567e17e103a564b67db7b04ddd3e
|
e3dd252c7464b7171a76e1f8f2784aebee5b438f
|
/src/tree/MinimumDepthOfBinaryTree.java
|
bda980ee765131e6e324264be68e5af4484fe27b
|
[] |
no_license
|
cserspring/leetcode
|
d6853a2798276b360bb65d222a2bb2435e4de360
|
76b07b81b73b176ba38d025775ab5b2b51c4c507
|
refs/heads/master
| 2020-05-21T04:22:09.408928 | 2016-11-01T06:09:42 | 2016-11-01T06:09:42 | 46,645,778 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 359 |
java
|
package tree;
public class MinimumDepthOfBinaryTree {
public int minDepth(TreeNode root) {
if (root == null) return 0;
if (root.left == null || root.right == null) return root.left == null ? (1 + minDepth(root.right)) : (1 + minDepth(root.left));
return Math.min(1 + minDepth(root.left), 1 + minDepth(root.right));
}
}
|
[
"[email protected]"
] | |
3b1323354e903ae62d76a46c2d50ad35a0f30dfc
|
822e712c7f18175d9a0cd2b47fb2d232c118d451
|
/src/main/java/br/quixada/ufc/controller/IndexController.java
|
e84fa895a66b450a8e8860c7a7e9d0adca2f0a91
|
[] |
no_license
|
hilderjares/simple-crud-spring-boot
|
7fd729d0052c38e53279ef96a5eb5fa53e017e11
|
364e1ba110c431c05cb723dc8c6be4106dd87545
|
refs/heads/master
| 2020-05-30T14:39:06.036368 | 2019-06-02T02:20:12 | 2019-06-02T02:20:12 | 189,796,136 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 267 |
java
|
package br.quixada.ufc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class IndexController {
@RequestMapping("/")
public String index() {
return "index";
}
}
|
[
"[email protected]"
] | |
312954dbda61906610b58d18ea1cc3690d07016d
|
2c9204aaf61003585a6a5e81daa833e4645745fb
|
/neteasy-enroll-manager/src/main/java/com/neteasy/manager/web/config/swagger/SwaggerConfig.java
|
f60badbaba104f5f8f5c132f6b2e60a0692cdbc6
|
[] |
no_license
|
Ivan252525/neteasy-enroll-server
|
ea8a50f1bf198e67bbfe277204f52b7db5adb109
|
98183d3650d458ae31cb5aa36abfacfbecc4202d
|
refs/heads/master
| 2022-07-14T02:29:54.683587 | 2020-03-06T02:54:03 | 2020-03-06T02:54:03 | 232,986,697 | 0 | 0 | null | 2022-06-29T17:54:27 | 2020-01-10T07:03:28 |
Java
|
UTF-8
|
Java
| false | false | 1,276 |
java
|
package com.neteasy.manager.web.config.swagger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
*
* @author Ivan
*/
@Configuration
@EnableSwagger2 // 开启swagger2
public class SwaggerConfig {
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.neteasy.manager.modules"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("网易江门报名系统API文档")
.description("网易江门报名系统API文档")
.version("1.0")
.build();
}
}
|
[
"[email protected]"
] | |
15ef38e99cf980f8c4aaa99a654be045f70094ac
|
3f4ece8324d96b1d5655bad4f6206ecd50d16a42
|
/TbusTestAppNT/src/de/hhu/tbus/applications/nt/emergencywarning/EmergencyWarningAppETSI.java
|
a05866432c319ba8013b34ae95fb73a0cc9538b7
|
[
"MIT"
] |
permissive
|
hhucn/tbus-applications
|
e68875d0d5b5a35ad35a73401024adf7fecac4a7
|
e2d5fcb813f04aa10904e975b0c351e95ae6bb41
|
refs/heads/master
| 2021-01-17T14:50:57.540091 | 2016-06-16T12:13:14 | 2016-06-16T12:13:14 | 44,972,145 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 3,424 |
java
|
/**
*
*/
package de.hhu.tbus.applications.nt.emergencywarning;
import java.util.UUID;
import com.dcaiti.vsimrti.fed.applicationNT.ambassador.simulationUnit.operatingSystem.OperatingSystem;
import com.dcaiti.vsimrti.fed.applicationNT.ambassador.util.UnitLogger;
import com.dcaiti.vsimrti.rti.eventScheduling.Event;
import com.dcaiti.vsimrti.rti.objects.v2x.ReceivedV2XMessage;
import com.dcaiti.vsimrti.rti.objects.v2x.V2XMessage;
import de.hhu.tbus.applications.nt.configuration.TbusConfiguration;
import de.hhu.tbus.applications.nt.emergencywarning.configuration.EmergencyWarningAppETSIConfiguration;
import de.hhu.tbus.applications.nt.emergencywarning.message.EmergencyWarningMessage;
import de.hhu.tbus.applications.nt.emergencywarning.message.EmergencyWarningMessage.EmergencyType;
import de.hhu.tbus.applications.nt.geoserver.edge.client.TbusGeoclientETSI;
/**
* @author bialon
*
*/
public class EmergencyWarningAppETSI extends TbusGeoclientETSI {
private EmergencyWarningAppETSIConfiguration config;
private void handleEmergencyWarningMessage(EmergencyWarningMessage msg) {
if (config.isEmergencyVehicle) {
// If this is an emergency vehicle, ignore EV messages
return;
}
long delay = getOperatingSystem().getSimulationTime() - msg.originalTimestamp;
if (delay > msg.getTimeout()) {
getLog().info("EmergencyWarningMessage timed out - Delay " + delay + "ns (" + (delay - msg.getTimeout()) + "ns too late)");
} else {
getLog().info("Slowing down to " + config.slowDownSpeed + " for " + config.obeyTime + "ms");
getOperatingSystem().slowDown(config.slowDownSpeed, config.obeyTime, null);
}
}
@Override
public void processEvent(Event evt) throws Exception {
super.processEvent(evt);
if (evt.getResource() == null) {
long now = getOperatingSystem().getSimulationTime();
getLog().info("Received event at simulation time " + now);
EmergencyWarningMessage msg = new EmergencyWarningMessage(getDefaultRouting(), EmergencyType.AMBULANCE, now, config.timeout, UUID.randomUUID());
startGeoBroadcast(msg, config.offset, config.interval, config.radius);
}
}
@Override
protected void initConfig() {
super.initConfig();
OperatingSystem os = getOperatingSystem();
UnitLogger log = getLog();
try {
config = (new TbusConfiguration<EmergencyWarningAppETSIConfiguration>()).readConfiguration(EmergencyWarningAppETSIConfiguration.class, EmergencyWarningAppETSIConfiguration.configFilename, os, log);
} catch (InstantiationException | IllegalAccessException ex) {
getLog().error("Cannot instantiate configuration object, using default configuration: ", ex);
config = new EmergencyWarningAppETSIConfiguration();
}
}
@Override
public void setUp() {
super.setUp();
getLog().info("Is emergency vehicle: " + config.isEmergencyVehicle);
if (config.isEmergencyVehicle) {
getLog().info("Now acting as emergency vehicle, geobroadcast starting in " + config.offset + "ns");
// Add start event
getOperatingSystem().getEventManager().addEvent(new Event(getOperatingSystem().getSimulationTime() + config.offset, this));
}
}
@Override
public void receiveV2XMessage(ReceivedV2XMessage recMsg) {
super.receiveV2XMessage(recMsg);
V2XMessage embMsg = recMsg.getMessage();
if (embMsg instanceof EmergencyWarningMessage) {
handleEmergencyWarningMessage((EmergencyWarningMessage) embMsg);
}
}
}
|
[
"[email protected]"
] | |
708c0b5b1a64bac73f49607332535607891685d8
|
aaf0601a842cacf3082d70907db7ca9dd8c4ff35
|
/Tetris/src/edu/cgxy/tetris/tools/DatabaseConnector.java
|
4b0927182458fd8de1e517538b84ed170b1d7bdf
|
[] |
no_license
|
MetSystem/Game
|
b764929ba130179879837f45b8fccd8e3d29ffd3
|
4d30e3e2a6cb07fa45d82c435a72305688794010
|
refs/heads/master
| 2021-01-15T08:58:59.021474 | 2015-05-14T00:03:54 | 2015-05-14T00:03:54 | 43,406,992 | 1 | 0 | null | 2015-09-30T02:27:56 | 2015-09-30T02:27:56 | null |
UTF-8
|
Java
| false | false | 68 |
java
|
package edu.cgxy.tetris.tools;
public class DatabaseConnector {
}
|
[
"[email protected]"
] | |
d4ab45d35414f1bc72f5bdb4a1836db59092026b
|
ef0992d27a48c0614bd3d4782d64d6a1bb252404
|
/01_Java/Test/0615_DaoDto_GUI/StudentDto.java
|
0a4b64d91a1358de01501bee2f83fbc6fe83cbfa
|
[] |
no_license
|
no-gomin/bigData
|
750748e80138bd063994500edaf093312912f4e0
|
1baf5775e5b1c5ce61a1ecfc7784d967c4f7ef79
|
refs/heads/main
| 2023-08-04T13:36:17.148241 | 2021-09-24T10:43:08 | 2021-09-24T10:43:08 | 366,351,074 | 0 | 0 | null | null | null | null |
UHC
|
Java
| false | false | 1,961 |
java
|
package com.lect.exam;
public class StudentDto {
private int mno;
private String mname;
private int sno;
private String sname;
// private int mno;
private int score;
private int sexpel;
private int rank;
private String mnameMno;
// 입력
public StudentDto(String sname, int mno, int score, int sexpel) {
this.sname = sname;
this.mno = mno;
this.score = score;
this.sexpel = sexpel;
}
// 학번 검색
public StudentDto(String sname, String mname, int score) {
this.sname = sname;
this.mname = mname;
this.score = score;
}
// 이름 검색
public StudentDto(int sno, String sname, String mname, int score) {
this.sno = sno;
this.sname = sname;
this.mname = mname;
this.score = score;
}
// 전공검색
public StudentDto(String rank, String sname, String mnameMno, int score) {
this.sno = sno;
this.sname = sname;
this.mnameMno = mnameMno;
this.score = score;
}
// 출력
public StudentDto(int mno, String mname, int sno, String sname, int score, int sexpel) {
this.mno = mno;
this.mname = mname;
this.sno = sno;
this.sname = sname;
this.score = score;
this.sexpel = sexpel;
}
// 학생 수정
public StudentDto(int sno, int score) {
this.score = score;
this.sno = sno;
}
// 제적 수정
public StudentDto(String sname) {
this.sname = sname;
}
@Override
public String toString() {
return "StudentDto [mno=" + mno + ", mname=" + mname + ", sno=" + sno + ", sname=" + sname + ", score=" + score
+ ", sexpel=" + sexpel + ", rank=" + rank + ", mnameMno=" + mnameMno + "]";
}
public int getMno() {
return mno;
}
public String getMname() {
return mname;
}
public int getSno() {
return sno;
}
public String getSname() {
return sname;
}
public int getScore() {
return score;
}
public int getSexpel() {
return sexpel;
}
public int getRank() {
return rank;
}
public String getMnameMno() {
return mnameMno;
}
}
|
[
"[email protected]"
] | |
fb7a70bf41dfccc3e68fae2fcd01ac90372db2c3
|
9122cf28169b2d053a26e5d5cefacda018fb95b9
|
/algorithm/amazononlineassessment/src/main/java/com/amazon/question/MergeKSortedLists.java
|
9915ce2b3feeaaea34ed2aa178916a8c7117fc3d
|
[] |
no_license
|
siddhantaws/DataStructure-Algorithm
|
661f8ab75bcb2d5c68616b1e71a25e459b6a797a
|
cbd5398f24e075320eedcb7a83807954509e9467
|
refs/heads/master
| 2023-04-08T03:32:31.791195 | 2023-03-19T13:26:42 | 2023-03-19T13:26:42 | 88,467,251 | 1 | 1 | null | 2022-05-16T17:39:19 | 2017-04-17T04:13:41 |
Java
|
UTF-8
|
Java
| false | false | 2,347 |
java
|
package com.amazon.question;
import org.w3c.dom.NodeList;
public class MergeKSortedLists {
private ListNode[] lists ;
public MergeKSortedLists(ListNode[] lists) {
this.lists = lists;
}
private ListNode mergeKLists(){
mergeKLists(0 , lists.length-1);
for(int i=0;i<lists.length;i++)
if(lists[i]!=null)
return lists[i];
return null;
}
private void mergeKLists(int l ,int r) {
if(l>r)
return;
else{
int mid = l + (r-l)/2;
mergeKLists(l,mid);
mergeKLists(mid+1,r);
ListNode first =null;ListNode second =null;
int fIndex =-1; int secondIndex =-1;
while(l<mid){
if(first==null && lists[l]!=null){
first =lists[l];
fIndex=l;
break;
}
}
l=mid+1;
while(l<r){
if(second==null && lists[l]!=null){
second =lists[l];
secondIndex=l;
break;
}
}
ListNode nodeList1 =merge(first , second);
lists[secondIndex]=null;
lists[fIndex]=nodeList1;
}
}
private ListNode merge(ListNode first, ListNode second){
if(first==null)
return second;
if(second==null)
return first;
else{
if(first.val<second.val){
first.next =merge(first.next,second);
return first;
}else {
second.next =merge(first,second.next);
return second;
}
}
}
public static void main(String[] args) {
ListNode node[] =new ListNode[3];
node[0]= new ListNode(1);node[0].next =new ListNode(4);node[0].next.next =new ListNode(5);
node[1]= new ListNode(1);node[1].next =new ListNode(3);node[1].next.next =new ListNode(4);
node[2]= new ListNode(2);node[2].next =new ListNode(6);
MergeKSortedLists sortedLists =new MergeKSortedLists(node);
ListNode node1 =sortedLists.mergeKLists();
}
static class ListNode {
int val;
ListNode next;
ListNode(int x) {
val = x;
}
}
}
|
[
"[email protected]"
] | |
d78e08328e1cc08e20a16eea297260d189fef013
|
c240df552d2865a707876ed9e971d1590ff0ebe0
|
/springcloud-microservice-workspace/springcloud-microservice-provider/springcloud-microservice-provider-common-api/src/main/java/com/ccb/springcloud/provider/common/model/Item.java
|
03bc9bd5eaccdb541771f4a0169439eea54b280b
|
[] |
no_license
|
turbobin/SpringBoot-Project
|
82536439fa9e0a6ea20b023dc1242a7d03bf3db5
|
ed3ea4280293f6bad82ecce3881e22b9f7219887
|
refs/heads/master
| 2020-05-17T06:58:09.604209 | 2019-04-26T06:19:15 | 2019-04-26T06:19:15 | 183,567,375 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,305 |
java
|
package com.ccb.springcloud.provider.common.model;
public class Item {
private Integer id;
private String title;
private String picture;
private String description;
private Integer price;
public Item() {
}
public Item(Integer id, String title, String picture, String description, Integer price) {
this.id = id;
this.title = title;
this.picture = picture;
this.description = description;
this.price = price;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title == null ? null : title.trim();
}
public String getPicture() {
return picture;
}
public void setPicture(String picture) {
this.picture = picture == null ? null : picture.trim();
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description == null ? null : description.trim();
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
}
|
[
"[email protected]"
] | |
a5a1d035c78ab7162c444378508353e8058021de
|
be73270af6be0a811bca4f1710dc6a038e4a8fd2
|
/crash-reproduction-moho/results/MOCKITO-7b-7-9-MOEAD-WeightedSum:TestLen:CallDiversity/org/mockito/internal/handler/InvocationNotifierHandler_ESTest_scaffolding.java
|
9e61d5bcc3ad1c0ae7318334c141efaf07c0024a
|
[] |
no_license
|
STAMP-project/Botsing-multi-objectivization-using-helper-objectives-application
|
cf118b23ecb87a8bf59643e42f7556b521d1f754
|
3bb39683f9c343b8ec94890a00b8f260d158dfe3
|
refs/heads/master
| 2022-07-29T14:44:00.774547 | 2020-08-10T15:14:49 | 2020-08-10T15:14:49 | 285,804,495 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 458 |
java
|
/**
* Scaffolding file used to store all the setups needed to run
* tests automatically generated by EvoSuite
* Wed Apr 08 12:07:19 UTC 2020
*/
package org.mockito.internal.handler;
import org.evosuite.runtime.annotation.EvoSuiteClassExclude;
import org.junit.BeforeClass;
import org.junit.Before;
import org.junit.After;
@EvoSuiteClassExclude
public class InvocationNotifierHandler_ESTest_scaffolding {
// Empty scaffolding for empty test suite
}
|
[
"[email protected]"
] | |
e64f34e5c1ff9c18bb4e8749885d2ab18f963fd3
|
1f542e79a6a84c7119f08ad812e48e0978ee6dc1
|
/Java/OOP1/src/finalKeyword/Test.java
|
64c0a9b3e4221febfb4db07b3657b7c43df64f98
|
[] |
no_license
|
murad034/All-Code-Semister
|
218dc4bc1cb6ece4b734664607bef7e80310498a
|
181b5d6e78bd724bfab0f72057b485e7538325e7
|
refs/heads/master
| 2022-04-03T01:06:36.983377 | 2020-02-04T10:55:33 | 2020-02-04T10:55:33 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 173 |
java
|
package finalKeyword;
public class Test {
public static void main(String[] args){
Student ob = new Student();
ob.display();
}
}
|
[
"[email protected]"
] | |
5d2691f1570663c5f8efb0b321990e2b42d23177
|
4c7d9a44ba804ddc9f29f56ea908f6877ac3645e
|
/iLife/src/main/java/ilife/music/model/Artist.java
|
8163c691c3a00d8dee41a36f2a7511552236318b
|
[] |
no_license
|
foobarjohnny/my_example2
|
58f1841ee82e61d4fd8ed16854be7b60b24dfa8b
|
5ed679613ddbca7cd8f2623143a0d481216993c8
|
refs/heads/master
| 2020-05-19T10:28:29.921238 | 2012-11-03T15:25:27 | 2012-11-03T15:25:27 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,176 |
java
|
package ilife.music.model;
import java.util.List;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Transient;
/**
*
* 艺术家
*/
@Entity
public class Artist {
@Id
@GeneratedValue
private Long id;
@Column(length = 50, nullable = false)
private String name;
@Transient
private Set<String> images;
@ManyToMany(mappedBy = "artists")
private List<Song> songs;
private String description;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<String> getImages() {
return images;
}
public void setImages(Set<String> images) {
this.images = images;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public List<Song> getSongs() {
return songs;
}
public void setSongs(List<Song> songs) {
this.songs = songs;
}
}
|
[
"[email protected]@7e0b5509-6f4a-8bf9-4c4a-278d71e247f9"
] |
[email protected]@7e0b5509-6f4a-8bf9-4c4a-278d71e247f9
|
d558a12ddeca7a359b5692dcc1559f0ea3279864
|
d722142fa0300d269aae16521373319b0385e6cd
|
/src/study/designmode/interpreter/Note.java
|
da9619e09b570662819b835871eca101b1b3b204
|
[
"MIT"
] |
permissive
|
qblank/leetcode
|
09ad53cc0d3c5fee1d437cae8ae6d7f4be858227
|
b8f3c816a175d995562a33ced431a9721fe5554f
|
refs/heads/master
| 2021-06-14T19:33:34.554018 | 2021-04-25T02:45:57 | 2021-04-25T02:45:57 | 186,341,399 | 2 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 882 |
java
|
package study.designmode.interpreter;
/**
* @version 1.0
* @date 2019/2/17 11:02
*/
public class Note extends AbstractExpression {
@Override
void execute(String key, double value) {
String note = "";
switch (key){
case "C":
note = "1";
break;
case "D":
note = "2";
break;
case "E":
note = "3";
break;
case "F":
note = "4";
break;
case "G":
note = "5";
break;
case "A":
note = "6";
break;
case "B":
note = "7";
break;
default:
note = "1";
break;
}
System.out.print(note + " ");
}
}
|
[
"[email protected]"
] | |
5cad0cd51edad9d3e2ecbacd8964f5f2a28b9206
|
e53144d7e303bd317dc7b31f747329008b97fb67
|
/TrabajoFinalMunnozCordonEstela/src/trabajoFinal/personajes/Razable.java
|
d22e5e3e7d48072d48389aef789d7f0bfafc9d41
|
[] |
no_license
|
Estelamc/TrabajoFinalPersonajes
|
126052d4b75401a8df2de7b1e8d19c43f89deeaf
|
715d9e1c7be9439caa4a564921e4764da39399e6
|
refs/heads/master
| 2021-01-10T17:11:23.220545 | 2015-06-07T02:44:42 | 2015-06-07T02:44:42 | 36,068,410 | 0 | 0 | null | 2015-06-07T02:44:42 | 2015-05-22T11:18:32 |
HTML
|
UTF-8
|
Java
| false | false | 492 |
java
|
package trabajoFinal.personajes;
/**
* Dependiendo de la raza del personaje, tendrá
* unas habilidades distintas; por ejemplo, un elfo
* tiene mayor velocidad que un humano.
*
* @author Estela Muñoz Cordón
* @version 1.0
*
*/
public interface Razable {
/**
* Actualiza las estadísticas del
* personaje según la raza que sea
* (fuerza, inteligencia, resistencia...).
*/
abstract void actualizarValores();
}
|
[
"[email protected]"
] | |
f69e507525351878e7d7ac8a5fa62f06ef86e48a
|
d0d9ba9fd4e3d88fc7d739649c1d51e2aa56bc6a
|
/ac.simons.bikingFX/main/java/ac/simons/bikingFX/bikingPictures/FlipImageService.java
|
9bd09b184fb408fe0e8990a405a5f40f2dd966c8
|
[
"Apache-2.0"
] |
permissive
|
IdelsTak/bikingFX
|
2e2a14a5b91c7429861cfd43b1f6dca46699d19a
|
c066ecc73e72bc68b595358f5af85dc986b897a7
|
refs/heads/master
| 2023-04-03T13:10:32.748700 | 2021-03-31T20:04:48 | 2021-03-31T20:04:48 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 4,073 |
java
|
/*
* Copyright 2014-2020 michael-simons.eu.
*
* 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 ac.simons.bikingFX.bikingPictures;
import ac.simons.bikingFX.RootController.LoadedImageFilter;
import javafx.animation.ScaleTransition;
import javafx.collections.ObservableList;
import javafx.concurrent.ScheduledService;
import javafx.concurrent.Task;
import javafx.scene.Node;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.layout.Pane;
import javafx.scene.layout.StackPane;
import javafx.util.Duration;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
/**
* @author Michael J. Simons
* @since 2014-10-17
*/
public class FlipImageService extends ScheduledService<ImageView> {
private static final Logger logger = Logger.getLogger(FlipImageService.class.getName());
private final ObservableList<BikingPicture> bikingPictures;
private final Random random;
private final Pane container;
public FlipImageService(ObservableList<BikingPicture> bikingPictures, final Pane container, final Random random) {
this.bikingPictures = bikingPictures;
this.container = container;
this.random = random;
this.setPeriod(Duration.seconds(10));
this.setDelay(this.getPeriod());
this.setOnSucceeded(state -> {
// Check if images are loaded...
final List<Node> currentImageViews = this.container.getChildren().filtered(
node -> node instanceof StackPane && ((StackPane) node).getChildren().get(0) instanceof ImageView);
if (currentImageViews.size() > 0) {
final StackPane pickedNoded = (StackPane) currentImageViews
.get(this.random.nextInt(currentImageViews.size()));
final Node back = (Node) state.getSource().getValue();
back.setScaleX(0);
pickedNoded.getChildren().add(back);
final Duration animDuration = Duration.millis(500);
final ScaleTransition hideFront = new ScaleTransition(animDuration, pickedNoded.getChildren().get(0));
hideFront.setFromX(1);
hideFront.setToX(0);
final ScaleTransition showBack = new ScaleTransition(animDuration, back);
showBack.setFromX(0);
showBack.setToX(1);
hideFront.setOnFinished(event -> showBack.play());
showBack.setOnFinished(event -> pickedNoded.getChildren().remove(0));
hideFront.play();
}
});
this.setOnFailed(state -> logger
.log(Level.INFO, "Could not create ImageView: {0}.", state.getSource().getException().getMessage()));
}
@Override
protected Task<ImageView> createTask() {
return new Task<ImageView>() {
@Override
protected ImageView call() throws Exception {
// Create fresh filtered list
final Set<BikingPicture> loadedBikingPictures = container
.getChildren().stream()
.filter(new LoadedImageFilter())
.map(node -> (BikingPicture) ((StackPane) node).getChildren().get(0).getUserData())
.collect(Collectors.toSet());
final List<BikingPicture> availableBikingPictures = bikingPictures
.filtered(bikingPicture -> !loadedBikingPictures.contains(bikingPicture));
if (availableBikingPictures.size() <= 0) {
throw new RuntimeException("No more pictures available");
}
final BikingPicture bikingPicture = availableBikingPictures
.get(random.nextInt(availableBikingPictures.size()));
final ImageView imageView = new ImageView(
new Image(bikingPicture.getSrc(), 150, 113, true, true, false));
imageView.setUserData(bikingPicture);
return imageView;
}
};
}
}
|
[
"[email protected]"
] | |
4dafd9e8b8b03b818a21fcde88e165aea78383ab
|
ca7a8d435c5e169edad8a707ff7bccf7d6f68928
|
/src/model/entradas/CtrlEmbViagemEnt.java
|
743591f94d8315050ff76bbdf8c2973607ecae52
|
[] |
no_license
|
cafeamerica/CafeAmerica3
|
bef342e7c0acd940b874e578e065aef747cf24a1
|
068e0ffe1ee57696f2db25ab932d1a2af7f695a1
|
refs/heads/master
| 2016-09-01T20:11:40.942636 | 2014-12-12T16:56:00 | 2014-12-12T16:56:00 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,387 |
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 model.entradas;
/**
*
* @author Rafael
*/
public class CtrlEmbViagemEnt {
private int id_ctrl_emb_viagem_ent;
private int id_tipo_emb;
private int id_viagem;
private int id_guia;
private double qtd_emb;
public CtrlEmbViagemEnt(){
}
public int getId_ctrl_emb_viagem_ent() {
return id_ctrl_emb_viagem_ent;
}
public void setId_ctrl_emb_viagem_ent(int id_ctrl_emb_viagem_ent) {
this.id_ctrl_emb_viagem_ent = id_ctrl_emb_viagem_ent;
}
public int getId_tipo_emb() {
return id_tipo_emb;
}
public void setId_tipo_emb(int id_tipo_emb) {
this.id_tipo_emb = id_tipo_emb;
}
public int getId_viagem() {
return id_viagem;
}
public void setId_viagem(int id_viagem) {
this.id_viagem = id_viagem;
}
public int getId_guia() {
return id_guia;
}
public void setId_guia(int id_guia) {
this.id_guia = id_guia;
}
public double getQtd_emb() {
return qtd_emb;
}
public void setQtd_emb(double qtd_emb) {
this.qtd_emb = qtd_emb;
}
}
|
[
""
] | |
48a21bdb80ca5092ae7dc744f787cb5eff87f167
|
0fea997477fed7afbf5dfa95c800237a259cc7d7
|
/BNR/LocationTracker/src/alexandervbarkov/android/bnr/locationtracker/FragmentRecordMap.java
|
1505a5d43b300b80728c61c36c42d7d189310ed4
|
[] |
no_license
|
alexandervbarkov/Android
|
f4771c92b3a3658644728304da8ab6c8556a7bcb
|
780d6cb457e73fe98243f5cd122aa77f47bebc6a
|
refs/heads/master
| 2021-06-18T00:14:48.180113 | 2017-03-26T04:35:06 | 2017-03-26T04:35:06 | 39,611,664 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 8,022 |
java
|
package alexandervbarkov.android.bnr.locationtracker;
import java.util.Date;
import alexandervbarkov.android.bnr.locationtracker.DatabaseHelperRecord.CursorLocations;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.IntentFilter;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.Color;
import android.location.Location;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.support.v4.app.LoaderManager.LoaderCallbacks;
import android.support.v4.content.Loader;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;
import com.google.android.gms.maps.CameraUpdate;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.GoogleMap.OnMapLoadedCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.BitmapDescriptorFactory;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.LatLngBounds;
import com.google.android.gms.maps.model.LatLngBounds.Builder;
import com.google.android.gms.maps.model.Marker;
import com.google.android.gms.maps.model.MarkerOptions;
import com.google.android.gms.maps.model.Polyline;
import com.google.android.gms.maps.model.PolylineOptions;
public class FragmentRecordMap extends SupportMapFragment implements LoaderCallbacks<Cursor> {
private static final String ARG_RECORD_ID = "record_id";
private static final int LOAD_LOCATIONS = 0;
private GoogleMap mGoogleMap;
private CursorLocations mCursorLocations;
private long mRecordId;
private Marker mFinishMarker;
private PolylineOptions mLineOptions;
private Polyline mLine;
private Builder mBuilder;
private boolean mCursorLoaded;
private boolean mMapLoaded;
private boolean mStartMarkerPlaced;
private BroadcastReceiver mLocationReceiver = new ReceiverLocation() {
@Override
protected void onLocationReceived(Context context, Location location) {
long trackingRecordId = PreferenceManager.getDefaultSharedPreferences(getActivity().getApplicationContext()).getLong(TrackerManager.PREF_CURRENT_RECORD_ID, -1);
if(mRecordId != trackingRecordId)
return;
updateMap(location);
}
@Override
protected void onProviderEngabledChanged(Context context, boolean enabled) {
int toastText = enabled ? R.string.toast_frag_tracker_gps_enabled : R.string.toast_frag_tracker_gps_disabled;
Toast.makeText(getActivity().getApplicationContext(), toastText, Toast.LENGTH_LONG).show();
}
};
public static FragmentRecordMap newInstance(long recordId) {
Bundle args = new Bundle();
args.putLong(ARG_RECORD_ID, recordId);
FragmentRecordMap fragment = new FragmentRecordMap();
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
mLineOptions = new PolylineOptions();
mLineOptions.color(Color.parseColor("#7fff0000"));
mLine = null;
mBuilder = new Builder();
mCursorLoaded = false;
mMapLoaded = false;
mStartMarkerPlaced = false;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup parent, Bundle savedInstanceState) {
View v = super.onCreateView(inflater, parent, savedInstanceState);
// Stash a reference to the GoogleMap
mGoogleMap = getMap();
mGoogleMap.setMyLocationEnabled(true);
mGoogleMap.setOnMapLoadedCallback(new OnMapLoadedCallback() {
@Override
public void onMapLoaded() {
mMapLoaded = true;
if(mCursorLoaded)
drawMap();
}
});
return v;
}
@Override
public void onStart() {
super.onStart();
getActivity().registerReceiver(mLocationReceiver, new IntentFilter(TrackerManager.ACTION_LOCATION));
}
@Override
public void onResume() {
Bundle args = getArguments();
if(args != null) {
mRecordId = args.getLong(ARG_RECORD_ID, -1);
if(mRecordId != -1)
getLoaderManager().initLoader(LOAD_LOCATIONS, args, this);
}
super.onResume();
}
@Override
public void onPause() {
getLoaderManager().destroyLoader(0);
super.onPause();
}
@Override
public void onStop() {
getActivity().unregisterReceiver(mLocationReceiver);
super.onStop();
}
public void drawMap() {
if(mGoogleMap == null || mCursorLocations == null)
return;
mLineOptions = new PolylineOptions();
mLineOptions.color(Color.parseColor("#7fff0000"));
mBuilder = new Builder();
mGoogleMap.clear();
boolean hasPoints = false;
mCursorLocations.moveToFirst();
while(!mCursorLocations.isAfterLast()) {
hasPoints = true;
mStartMarkerPlaced = true;
// Create line
Location location = mCursorLocations.getLocation();
LatLng point = new LatLng(location.getLatitude(), location.getLongitude());
mLineOptions.add(point);
mBuilder.include(point);
// Create markers
Resources r = getResources();
if(mCursorLocations.isFirst()) {
String startTime = new Date(location.getTime()).toString();
MarkerOptions startMarker = new MarkerOptions().
position(point).
title(r.getString(R.string.label_frag_record_run_start)).
snippet(r.getString(R.string.label_frag_record_run_started_at, startTime));
mGoogleMap.addMarker(startMarker);
}
else if(mCursorLocations.isLast()) {
String finishTime = new Date(location.getTime()).toString();
MarkerOptions finishMarker = new MarkerOptions().
position(point).
title(r.getString(R.string.label_frag_record_run_finish)).
snippet(r.getString(R.string.label_frag_record_run_finished_at, finishTime)).
icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_AZURE));
mFinishMarker = mGoogleMap.addMarker(finishMarker);
}
mCursorLocations.moveToNext();
}
if(hasPoints) {
mLine = mGoogleMap.addPolyline(mLineOptions);
LatLngBounds bounds = mBuilder.build();
CameraUpdate movement = CameraUpdateFactory.newLatLngBounds(bounds, 50);
mGoogleMap.moveCamera(movement);
}
}
private void updateMap(Location location) {
if(!mMapLoaded)
return;
LatLng point = new LatLng(location.getLatitude(), location.getLongitude());
mLineOptions.add(point);
mBuilder.include(point);
Resources r = getResources();
if(!mStartMarkerPlaced) {
mStartMarkerPlaced = true;
String startTime = new Date(location.getTime()).toString();
MarkerOptions startMarker = new MarkerOptions().
position(point).
title(r.getString(R.string.label_frag_record_run_start)).
snippet(r.getString(R.string.label_frag_record_run_started_at, startTime));
mGoogleMap.addMarker(startMarker);
}
if(mFinishMarker != null)
mFinishMarker.remove();
String finishTime = new Date(location.getTime()).toString();
MarkerOptions finishMarker = new MarkerOptions().
position(point).
title(r.getString(R.string.label_frag_record_run_finish)).
snippet(r.getString(R.string.label_frag_record_run_finished_at, finishTime)).
icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_AZURE));
mFinishMarker = mGoogleMap.addMarker(finishMarker);
LatLngBounds bounds = mBuilder.build();
CameraUpdate movement = CameraUpdateFactory.newLatLngBounds(bounds, 50);
mGoogleMap.moveCamera(movement);
if(mLine != null)
mLine.remove();
mLine = mGoogleMap.addPolyline(mLineOptions);
}
@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args) {
return new LoaderLocationsListCursor(getActivity().getApplicationContext(), args.getLong(ARG_RECORD_ID, -1));
}
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
mCursorLocations = (CursorLocations)cursor;
mCursorLoaded = true;
if(mMapLoaded)
drawMap();
}
@Override
public void onLoaderReset(Loader<Cursor> loader) {
mCursorLocations.close();
mCursorLocations = null;
}
}
|
[
"[email protected]"
] | |
599f7983ab0b8c556b79fb7199cce730399f5d29
|
ba6043f445db92082bcc563ee5c6ca0292764a0e
|
/src/main/java/com/main/mod/Items/ItemsMO.java
|
2e30b20d48431b788f96f6a55c8dde26e6adf564
|
[] |
no_license
|
Mr1shaggy/MegaOre1.7.10
|
bf3f3d5b5f80229a4d503fe315b00099c1f6e7ca
|
237fef1e7181bf4c12e90e746fbe63f907d522bd
|
refs/heads/master
| 2021-01-10T20:06:32.878646 | 2014-11-29T20:58:33 | 2014-11-29T20:58:33 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 869 |
java
|
package com.main.mod.Items;
import cpw.mods.fml.common.registry.GameRegistry;
import net.minecraft.item.Item;
import static com.main.mod.Items.ItemDecMO.*;
/**
* Created by brandon on 11/28/14.
*/
public class ItemsMO {
public static void init() {
registerItems();
}
public static void registerItems() {
itemCopperIngot = registerItem(new SimpleItemsMO().setUnlocalizedName("CopperIngot"));
itemNickelIngot = registerItem(new SimpleItemsMO().setUnlocalizedName("NickelIngot"));
itemTinIngot = registerItem(new SimpleItemsMO().setUnlocalizedName("TinIngot"));
itemSteelIngot = registerItem(new SimpleItemsMO().setUnlocalizedName("SteelIngot"));
}
public static Item registerItem(Item item) {
GameRegistry.registerItem(item, item.getUnlocalizedName().substring(5));
return item;
}
}
|
[
"[email protected]"
] | |
d4b900bfe205c78f6aa7b4b471242f47e23202f3
|
cfe621e8c36e6ac5053a2c4f7129a13ea9f9f66b
|
/AndroidApplications/com.zeptolab.ctr.ads-912244/src/com/google/android/gms/location/LocationStatusCodes.java
|
04b50c0fbc0dacb6b7523071af72ec416e4ac728
|
[] |
no_license
|
linux86/AndoirdSecurity
|
3165de73b37f53070cd6b435e180a2cb58d6f672
|
1e72a3c1f7a72ea9cd12048d9874a8651e0aede7
|
refs/heads/master
| 2021-01-11T01:20:58.986651 | 2016-04-05T17:14:26 | 2016-04-05T17:14:26 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 552 |
java
|
package com.google.android.gms.location;
public final class LocationStatusCodes {
public static final int ERROR = 1;
public static final int GEOFENCE_NOT_AVAILABLE = 1000;
public static final int GEOFENCE_TOO_MANY_GEOFENCES = 1001;
public static final int GEOFENCE_TOO_MANY_PENDING_INTENTS = 1002;
public static final int SUCCESS = 0;
private LocationStatusCodes() {
}
public static int bl(int i) {
if (i >= 0 && i <= 1) {
return i;
}
return (1000 > i || i > 1002) ? 1 : i;
}
}
|
[
"[email protected]"
] | |
3c2727cd9a06b35ed9e9b98291d99bc1d6a58988
|
99689309154e66a0702920a3bb1ea4ce2875445b
|
/src/main/java/br/com/arthurdias/cursomc/repositories/CategoriaRepository.java
|
8d92d3a7d9746a4ce7e49f7a261ebddf533a1491
|
[] |
no_license
|
arthurdias-trad/curso-nelio-spring-boot
|
ea2e0d612d8d998e04830360fdc1875dec530e81
|
cff037fd48095225ecd58db7ae63e8c83c34ac4b
|
refs/heads/master
| 2022-12-31T08:49:38.300599 | 2020-10-20T12:30:00 | 2020-10-20T12:30:00 | 292,857,503 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 313 |
java
|
package br.com.arthurdias.cursomc.repositories;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import br.com.arthurdias.cursomc.domain.Categoria;
@Repository
public interface CategoriaRepository extends JpaRepository<Categoria, Integer>{
}
|
[
"[email protected]"
] | |
a79ec2718af40c6a22eedfb95f9cb2b77dce5e90
|
a57883b815a9d959e015c7a4144458ebdb90c455
|
/src/com/team2/m4/userBoardDAO.java
|
86aa791d90c2605a2017af4f7c2ebfbc8cac9b8a
|
[] |
no_license
|
kimjinkyung0501/semiProject
|
880d2d1bcae32d752777de49f34845923b8ed492
|
b8fe1eafa00c188acfcfe2351f39e9eab30f2758
|
refs/heads/master
| 2023-06-25T03:45:48.304880 | 2021-07-27T11:57:35 | 2021-07-27T11:57:35 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 11,218 |
java
|
package com.team2.m4;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import javax.security.auth.message.callback.PrivateKeyCallback.Request;
import javax.servlet.http.HttpServletRequest;
import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;
import com.team2.hc.DBManager;
import com.team2.hc.TokenMaker;
import com.team2.m1.Board;
public class userBoardDAO {
private ArrayList<Review> reviews;
private static final userBoardDAO UDAO = new userBoardDAO();
private userBoardDAO() {
// TODO Auto-generated constructor stub
}
public static userBoardDAO getUdao() {
return UDAO;
}
public void getAllReviews(HttpServletRequest request) {
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
con = DBManager.connect();
String sql = "select * from userboard order by ub_date";
pstmt = con.prepareStatement(sql);
rs = pstmt.executeQuery();
reviews = new ArrayList<Review>();
Review r = null;
while (rs.next()) {
r = new Review();
r.setUb_no(rs.getInt("ub_no"));
r.setUb_title(rs.getString("ub_title"));
r.setUb_content(rs.getString("ub_content"));
r.setUb_file(rs.getString("ub_file"));
r.setUb_date(rs.getDate("ub_date"));
r.setUb_id(rs.getString("ub_id"));
r.setUb_count(rs.getInt("ub_count"));
reviews.add(r);
}
request.setAttribute("reviews", reviews);
} catch (Exception e) {
e.printStackTrace();
} finally {
DBManager.close(con, pstmt, rs);
}
}
public void regReviews(HttpServletRequest request) {
Connection con = null;
PreparedStatement pstmt = null;
String bbb =(String)request.getAttribute("token");
Date dd = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("ss");
String aaa = sdf.format(dd);
System.out.println(aaa);
if (bbb.equals(aaa)) {
try {
con = DBManager.connect();
String sql = "insert into userboard values (userboard_seq.nextval, ?, ?, ?, sysdate, ?,0)";
pstmt = con.prepareStatement(sql);
String saveDirectory = request.getServletContext().getRealPath("img");
System.out.println(saveDirectory);
MultipartRequest mr = new MultipartRequest(request, saveDirectory, 31457280, "utf-8", new DefaultFileRenamePolicy());
String title = mr.getParameter("title");
String content = mr.getParameter("content");
String file = mr.getFilesystemName("file");
String id = mr.getParameter("id");
// ���� �� �ް� ���� �װ� �Ʒ� ����ǥ ä�� �� ���� ��.
pstmt.setString(1, title);
pstmt.setString(2, content);
pstmt.setString(3, file);
pstmt.setString(4, id);
if(pstmt.executeUpdate() == 1) {
request.setAttribute("r", "성공!");
} else {
request.setAttribute("r", "실패!!!");
}
} catch (Exception e) {
request.setAttribute("r", "DB");
e.printStackTrace();
} finally {
DBManager.close(con, pstmt, null);
}
}
}
public void count(HttpServletRequest request) {
Connection con = null;
PreparedStatement pstmt = null;
String bbb =(String)request.getAttribute("token");
Date dd = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("ss");
String aaa = sdf.format(dd);
System.out.println(aaa);
if (bbb.equals(aaa)) {
try {
con=DBManager.connect();
String sql = "update userboard set ub_count=ub_count+1 where ub_no=?";
pstmt=con.prepareStatement(sql);
pstmt.setInt(1, Integer.parseInt(request.getParameter("no")));
pstmt.executeQuery();
} catch (Exception e) {
// TODO: handle exception
}finally {
DBManager.close(con, pstmt, null);
}
}
}
public void getReview(HttpServletRequest request) {
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
Review dt = null;
try {
con = DBManager.connect();
String sql = "select * from userboard where ub_no=?";
pstmt = con.prepareStatement(sql);
int no = Integer.parseInt(request.getParameter("no"));
pstmt.setInt(1, no);
rs = pstmt.executeQuery();
if (rs.next()) {
dt = new Review();
dt.setUb_no(rs.getInt("ub_no"));
dt.setUb_title(rs.getString("ub_title"));
dt.setUb_content(rs.getString("ub_content"));
dt.setUb_file(rs.getString("ub_file"));
dt.setUb_date(rs.getDate("ub_date"));
dt.setUb_id(rs.getString("ub_id"));
dt.setUb_count(rs.getInt("ub_count"));
}
//�����
request.setAttribute("dt", dt);
} catch (Exception e) {
request.setAttribute("r", "DB실패");
e.printStackTrace();
} finally {
DBManager.close(con, pstmt, null);
}
}
public void reviewDel(HttpServletRequest request) {
Connection con = null;
PreparedStatement pstmt = null;
try {
con = DBManager.connect();
String sql = "delete userboard where ub_no = ?";
pstmt = con.prepareStatement(sql);
String no = request.getParameter("no");
pstmt.setString(1, no);
if(pstmt.executeUpdate() == 1) {
request.setAttribute("r", "삭제 성공");
} else {
request.setAttribute("r", "삭제 실패");
}
} catch (Exception e) {
e.printStackTrace();
request.setAttribute("r", "DB 실패");
} finally {
DBManager.close(con, pstmt, null);
}
}
public void search(HttpServletRequest request) {
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
con = DBManager.connect();
String type = request.getParameter("type");
String txt = request.getParameter("txt");
if (type.equals("all")) {
String sql = "select * from userboard where ub_title like '%' || ? || '%' or ub_content like '%' || ? || '%'";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, txt);
pstmt.setString(2, txt);
} else if (type.equals("title")) {
String sql = "select * from userboard where ub_title like '%' || ? || '%'";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, txt);
} else if (type.equals("text")) {
String sql = "select * from userboard where ub_content like '%' || ? || '%'";
pstmt = con.prepareStatement(sql);
pstmt.setString(1, txt);
}
rs = pstmt.executeQuery();
reviews = new ArrayList<Review>();
Review r = null;
while (rs.next()) {
// 占쏙옙체 Bean 占십울옙.
r = new Review();
r.setUb_no(rs.getInt("ub_no"));
r.setUb_title(rs.getString("ub_title"));
r.setUb_content(rs.getString("ub_content"));
r.setUb_file(rs.getString("ub_file"));
r.setUb_date(rs.getDate("ub_date"));
r.setUb_id(rs.getString("ub_id"));
r.setUb_count(rs.getInt("ub_count"));
reviews.add(r);
}
request.setAttribute("reviews", reviews);
} catch (Exception e) {
e.printStackTrace();
} finally {
DBManager.close(con, pstmt, rs);
}
}
public void update(HttpServletRequest request) {
// TODO Auto-generated method stub
Connection con = null;
PreparedStatement pstmt = null;
try {
con = DBManager.connect();
String sql = "update userboard set ub_title=?, ub_content=?,ub_file=?, ub_date=sysdate where ub_no=?";
pstmt = con.prepareStatement(sql);
String saveDirectory = request.getServletContext().getRealPath("img");
System.out.println(saveDirectory);
MultipartRequest mr = new MultipartRequest(request, saveDirectory, 31457280, "utf-8",
new DefaultFileRenamePolicy());
String title = mr.getParameter("title");
String content = mr.getParameter("content");
String file = mr.getFilesystemName("file");
String fName22 = mr.getParameter("file22");
int no = Integer.parseInt(mr.getParameter("no"));
System.out.println(title);
System.out.println(content);
System.out.println(file);
System.out.println(fName22);
System.out.println(no);
pstmt.setString(1, title);
pstmt.setString(2, content);
if (file != null) {
pstmt.setString(3, file);
} else if (file == null) {
pstmt.setString(3, fName22);
}
pstmt.setInt(4, no);
if (pstmt.executeUpdate() == 1) {
request.setAttribute("r", "수정!");
} else {
request.setAttribute("r", "실패!!!");
}
} catch (Exception e) {
request.setAttribute("r", "DB");
e.printStackTrace();
} finally {
DBManager.close(con, pstmt, null);
}
}
public void paging(int page, HttpServletRequest request) {
request.setAttribute("curPageNO", page);
int cnt = 10; // 占쏙옙占쏙옙占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙
int total = reviews.size(); // 占쏙옙 占쏙옙占쏙옙占쏙옙 占쏙옙占쏙옙
if (total != 0) {
int pageCount = (int) Math.ceil(total / (double) cnt);
request.setAttribute("pageCount", pageCount);
int start = total - (cnt * (page - 1));
int end = (page == pageCount) ? -1 : start - (cnt + 1);
ArrayList<Review> items = new ArrayList<Review>();
for (int i = start - 1; i > end; i--) {
items.add(reviews.get(i));
}
request.setAttribute("reviews", items);
}
}
public void best(HttpServletRequest request) {
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
con = DBManager.connect();
String sql = "select * from userboard order by ub_count desc";
pstmt = con.prepareStatement(sql);
rs = pstmt.executeQuery();
reviews = new ArrayList<Review>();
Review r = null;
while (rs.next()) {
r = new Review();
r.setUb_no(rs.getInt("ub_no"));
r.setUb_title(rs.getString("ub_title"));
r.setUb_content(rs.getString("ub_content"));
r.setUb_file(rs.getString("ub_file"));
r.setUb_date(rs.getDate("ub_date"));
r.setUb_id(rs.getString("ub_id"));
r.setUb_count(rs.getInt("ub_count"));
reviews.add(r);
}
request.setAttribute("reviews2", reviews);
} catch (Exception e) {
e.printStackTrace();
} finally {
DBManager.close(con, pstmt, rs);
}
}
}
|
[
"[email protected]"
] | |
6e045e5f7c0407d5a0559ae7f5d756e97de0de4d
|
1e042282ab3422b40c0bcfcaf540b3e34d05f443
|
/app/src/main/java/com/iamriyaz/tringo/data/Video.java
|
8988f120b7f648b50de8b237815d2fc6308f1f8a
|
[
"MIT"
] |
permissive
|
Hasnain05/Tringo
|
68f92253fc8df9292e6e723ceb1620b46c68a633
|
da35b9b48e2662387a1588be7993cde482351006
|
refs/heads/master
| 2020-06-23T23:24:37.178489 | 2018-07-24T05:53:58 | 2018-07-24T05:53:58 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,176 |
java
|
package com.iamriyaz.tringo.data;
import android.text.TextUtils;
import com.google.gson.annotations.SerializedName;
/**
* model POJO for a single trailer video
*
* Created on 11 Jun, 2018
* @author Riyaz
*/
public class Video {
public enum Type {
@SerializedName("Trailer")
TRAILER,
@SerializedName("Teaser")
TEASER,
@SerializedName("Clip")
CLIP,
@SerializedName("Featurette")
FEATURETTE
}
@SerializedName("id")
private String id;
@SerializedName("key")
private String key;
@SerializedName("site")
private String site;
@SerializedName("type")
private Type type;
public boolean isFromYouTube(){
return TextUtils.equals("YouTube", site);
}
//------------------ GENERATED ------------------//
public String getId() {
return id;
}
public String getKey() {
return key;
}
public String getSite() {
return site;
}
public Type getType() {
return type;
}
@Override public String toString() {
return "Video{" +
"id='" + id + '\'' +
", key='" + key + '\'' +
", site='" + site + '\'' +
", type=" + type +
'}';
}
}
|
[
"[email protected]"
] | |
4b63f646f8d0d476e82aee062b248afc3a42a88c
|
e7b89c9e2a9a4728e86df154e9242cd87ea4adae
|
/lab10/src/datastructures/LinkedListNode.java
|
aed30d6d5b13243f17f4c5ad4caecbd733e00016
|
[] |
no_license
|
reginazye/Object-Oriented-
|
d3995d214b05a9938f1b87b0d555827a7a9e18e0
|
58d620435e0915decadf903bdc5c58504573c199
|
refs/heads/master
| 2020-07-25T13:09:58.533895 | 2017-01-11T01:25:53 | 2017-01-11T01:25:53 | 73,775,908 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 934 |
java
|
package datastructures;
import datastructures.LinkedListNode;
/**
* Linked List node class
*
* @author ReginaYe
*
* @param <T>
*/
public class LinkedListNode<T> {
public T data;
public LinkedListNode<T> next;
/**
* constructor for linked list node
*
* @param data
*/
public LinkedListNode(T data){
setData(data);
}
/**
* Set the data stored at this node.
* @param data
*/
public void setData( T data ){
this.data = data;
}
/**
* Get the data stored at this node.
*/
public T getData(){
return data;
}
/**
* Set the next pointer to passed node.
* @param node
*/
public void setNext( LinkedListNode<T> node ){
this.next = node;
}
/**
* Get (pointer to) next node.
*/
public LinkedListNode<T> getNext(){
return next;
}
/**
* Returns a String representation of this node.
*/
public String toString(){
String s = data.toString();
return s;
}
}
|
[
"[email protected]"
] | |
794a26d4c5881e4d3e00cb9717b06817539375f7
|
3e81486524e9f366b0cd4cb01ea1a78a84437beb
|
/kaleido-core/src/main/java/org/kaleidofoundry/core/config/NamedConfiguration.java
|
8fd6c946130200b8b6d2c99de0eb84cc78173c72
|
[
"Apache-2.0"
] |
permissive
|
jraduget/kaleido-repository
|
952a2bd21db5df5478657d73242da128154070d0
|
19b0b931874fa76cf69fb36d70596760ebd506e7
|
refs/heads/master
| 2023-06-30T09:33:00.020680 | 2022-01-05T22:24:07 | 2022-01-05T22:24:07 | 743,632 | 0 | 1 |
Apache-2.0
| 2023-06-20T02:53:54 | 2010-06-27T19:10:16 |
Java
|
UTF-8
|
Java
| false | false | 1,223 |
java
|
/*
* Copyright 2008-2021 the original author or 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 org.kaleidofoundry.core.config;
import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.net.URI;
/**
* Annotation to inject configuration resources
*
* @author jraduget
*/
@Documented
@Target({ TYPE })
@Retention(RUNTIME)
public @interface NamedConfiguration {
/**
* @return name identifier
*/
String name();
/**
* @return resource {@link URI}
*/
String uri();
}
|
[
"[email protected]"
] | |
bdb95d94d5a84f67f130f4b5b5cbeb0976b01807
|
fce84bc3993f1e5e870754fb2f29fee3cec5ca6b
|
/myPortfolioSpring/src/main/java/com/myportfoliospring/repository/PersonRepository.java
|
86cface73469fa54366056ce9154a384ac013fe2
|
[] |
no_license
|
omaag06/SpringAndAngular
|
c259d5d15fe8e5fc29d280e4e086bd5bbc03dcfc
|
75a9459750d9dc0fc601b11b9cb7ce04a549fea7
|
refs/heads/master
| 2021-07-04T19:38:55.537761 | 2017-09-27T22:15:58 | 2017-09-27T22:15:58 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 497 |
java
|
package com.myportfoliospring.repository;
import java.io.Serializable;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.myportfoliospring.entity.Person;
@Repository("personRepository")
public interface PersonRepository extends JpaRepository<Person, Serializable> {
public abstract Person findById (int id);
public abstract List<Person> findByFirstNameStartsWith (String firstName);
}
|
[
"[email protected]"
] | |
dac25d4784c3fad5c4dbce1a0a5add26fda5ac9e
|
a3b065c0449271ba05783b7c6bd580293c6ae0c0
|
/tmall-pojo/src/main/java/org/skysigh/tmall/pojo/TbContentCategoryExample.java
|
02d6e1196be91a5f631ab74c5446d0421f95860a
|
[] |
no_license
|
skysigh/tmall
|
230958d0b970879d262dffa95cf89790ee64c765
|
758830c2ec0c929501e1493f1190d7df4f69ed01
|
refs/heads/master
| 2022-12-24T02:39:41.230881 | 2019-08-26T10:10:03 | 2019-08-26T10:10:03 | 203,784,979 | 0 | 0 | null | 2022-12-16T00:38:35 | 2019-08-22T11:53:49 |
JavaScript
|
UTF-8
|
Java
| false | false | 9,497 |
java
|
package org.skysigh.tmall.pojo;
import java.util.ArrayList;
import java.util.List;
public class TbContentCategoryExample {
protected String orderByClause;
protected boolean distinct;
protected List<Criteria> oredCriteria;
public TbContentCategoryExample() {
oredCriteria = new ArrayList<Criteria>();
}
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
public String getOrderByClause() {
return orderByClause;
}
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
public boolean isDistinct() {
return distinct;
}
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
public boolean isValid() {
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
return criteria;
}
public List<Criterion> getCriteria() {
return criteria;
}
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value));
}
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
}
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andNameIsNull() {
addCriterion("name is null");
return (Criteria) this;
}
public Criteria andNameIsNotNull() {
addCriterion("name is not null");
return (Criteria) this;
}
public Criteria andNameEqualTo(String value) {
addCriterion("name =", value, "name");
return (Criteria) this;
}
public Criteria andNameNotEqualTo(String value) {
addCriterion("name <>", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThan(String value) {
addCriterion("name >", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThanOrEqualTo(String value) {
addCriterion("name >=", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThan(String value) {
addCriterion("name <", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThanOrEqualTo(String value) {
addCriterion("name <=", value, "name");
return (Criteria) this;
}
public Criteria andNameLike(String value) {
addCriterion("name like", value, "name");
return (Criteria) this;
}
public Criteria andNameNotLike(String value) {
addCriterion("name not like", value, "name");
return (Criteria) this;
}
public Criteria andNameIn(List<String> values) {
addCriterion("name in", values, "name");
return (Criteria) this;
}
public Criteria andNameNotIn(List<String> values) {
addCriterion("name not in", values, "name");
return (Criteria) this;
}
public Criteria andNameBetween(String value1, String value2) {
addCriterion("name between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andNameNotBetween(String value1, String value2) {
addCriterion("name not between", value1, value2, "name");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition;
private Object value;
private Object secondValue;
private boolean noValue;
private boolean singleValue;
private boolean betweenValue;
private boolean listValue;
private String typeHandler;
public String getCondition() {
return condition;
}
public Object getValue() {
return value;
}
public Object getSecondValue() {
return secondValue;
}
public boolean isNoValue() {
return noValue;
}
public boolean isSingleValue() {
return singleValue;
}
public boolean isBetweenValue() {
return betweenValue;
}
public boolean isListValue() {
return listValue;
}
public String getTypeHandler() {
return typeHandler;
}
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.typeHandler = typeHandler;
if (value instanceof List<?>) {
this.listValue = true;
} else {
this.singleValue = true;
}
}
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
this.value = value;
this.secondValue = secondValue;
this.typeHandler = typeHandler;
this.betweenValue = true;
}
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}
|
[
"[email protected]"
] | |
1b305f96df705e5651a521528496e7d2b5425edb
|
8c05a7cc9ec806b290ed1472b16905b3e18d687a
|
/app/src/main/java/com/dotworld/bairebike/adapter/NavigationDrawerAdapter.java
|
db9c5228116f00355b01acdeeb68196c999f766e
|
[] |
no_license
|
martinovic/BikeBaires
|
c35dee541d97f9bf16d88f5abbaf5b5b5cdfb915
|
99046962433599007a8e4d1528b71c95cdbe5210
|
refs/heads/master
| 2020-05-02T13:13:25.622307 | 2015-07-10T01:58:05 | 2015-07-10T01:58:05 | 38,855,173 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,739 |
java
|
package com.dotworld.bairebike.adapter;
import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import java.util.Collections;
import java.util.List;
import com.dotworld.bairebike.R;
import com.dotworld.bairebike.model.NavDrawerItem;
/**
* Created by Ravi Tamada on 12-03-2015.
*/
public class NavigationDrawerAdapter extends RecyclerView.Adapter<NavigationDrawerAdapter.MyViewHolder> {
List<NavDrawerItem> data = Collections.emptyList();
private LayoutInflater inflater;
private Context context;
public NavigationDrawerAdapter(Context context, List<NavDrawerItem> data) {
this.context = context;
inflater = LayoutInflater.from(context);
this.data = data;
}
public void delete(int position) {
data.remove(position);
notifyItemRemoved(position);
}
@Override
public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view = inflater.inflate(R.layout.nav_drawer_row, parent, false);
MyViewHolder holder = new MyViewHolder(view);
return holder;
}
@Override
public void onBindViewHolder(MyViewHolder holder, int position) {
NavDrawerItem current = data.get(position);
holder.title.setText(current.getTitle());
}
@Override
public int getItemCount() {
return data.size();
}
class MyViewHolder extends RecyclerView.ViewHolder {
TextView title;
public MyViewHolder(View itemView) {
super(itemView);
title = (TextView) itemView.findViewById(R.id.title);
}
}
}
|
[
"[email protected]"
] | |
b4c7ed63bb1698c695fe3a5bde9eab49fbcb0f5b
|
26d603d94eb6434998b66b388f7d1ea0963e2c01
|
/src/main/java/org/smtlib/Driver.java
|
408836a22b2874a841e69d9f9a5e9990525cd2fc
|
[
"MIT"
] |
permissive
|
mechtaev/repair-synthesis
|
5730ddc5b56612b5fac2b76b5bef80f64c6b4905
|
29063df1795a0670e9ae7bfe7351320a9db2f913
|
refs/heads/master
| 2020-05-20T19:30:11.763994 | 2019-03-11T18:58:24 | 2019-03-11T18:58:24 | 35,628,053 | 4 | 2 | null | null | null | null |
UTF-8
|
Java
| false | false | 6,546 |
java
|
/*
* This file is part of the SMT project.
* Copyright 2010 David R. Cok
* Created August 2010
*/
package org.smtlib;
import java.io.*;
import java.net.*;
import java.util.LinkedList;
import java.util.List;
// TODO - must be sure that the server prints success and is interactive
// TODO _ add other options? smtConfig echo; allow getting port from a env. variable - same one as used by server
/** The Driver class is a client that can send commands to the SMT application acting as a server. */
public class Driver {
// These constants are exit codes emitted from the application
/** The exit code corresponding to a 'success' response to an SMT-LIB command */
static final int EX_SUCCESS = 0;
/** The exit code corresponding to a 'sat' response to an SMT-LIB command */
static final int EX_SMT_SAT = 2;
/** The exit code corresponding to a 'unsat' response to an SMT-LIB command */
static final int EX_SMT_UNSAT = 3;
/** The exit code corresponding to a 'unknown' response to an SMT-LIB command */
static final int EX_SMT_UNKNOWN = 4;
/** The exit code corresponding to any other response to an SMT-LIB command */
static final int EX_SMT_OTHER = 5;
/** The exit code corresponding to and 'error' response to an SMT-LIB command */
static final int EX_SMT_ERROR = 10;
/** The exit code used when there is an error in the command-line arguments */
static final int EX_CMD_LINE_ERROR = 11;
/** The exit code used when there is an internal exception in the application */
static final int EX_EXCEPTION = 12;
/** The port to which to send commands (set as a command-line option)*/
protected int port = 0;
/** If true, verbose, debugging information is emitted by the application (set as a command-line option)*/
protected boolean verbose = false;
/** If true, do not echo 'success' responses (unless verbose is enabled) */
protected boolean quiet = false;
/** Whether to start a service process from this process */
protected boolean start = false;
/** The commands as specified on the command-line */
protected List<String> commands = new LinkedList<String>();
/** The main entry point to the application
* @param args the command-line arguments
*/
// public static void main(String[] args) {
// int exitCode = (new Driver()).exec(args);
// System.exit(exitCode);
// }
/** The non-static entry point to the application
* @param args the command-line arguments
* @return the exit code
*/
public int exec(String[] args) {
int exitCode = processOptions(args);
if (exitCode != 0) return exitCode>0 ? exitCode : 0;
if (port <= 0) {
System.out.println("Error: no port is specified");
return EX_CMD_LINE_ERROR;
}
try {
return send();
} catch (java.io.IOException e) {
System.out.println(e);
e.printStackTrace(System.out);
}
return EX_EXCEPTION;
}
/** Sets the fields of the class according to the command-line */
protected int processOptions(String[] args) {
int i = 0;
while (i < args.length) {
if ("--port".equals(args[i]) || "-p".equals(args[i])) {
++i;
if (i >= args.length) {
System.out.println("--port option must have an integer value");
return EX_CMD_LINE_ERROR;
} else {
try {
port = Integer.valueOf(args[i]).intValue();
} catch (NumberFormatException e) {
System.out.println(e);
return EX_CMD_LINE_ERROR;
}
}
} else if ("--verbose".equals(args[i]) || "-v".equals(args[i])) {
verbose = true;
quiet = false;
} else if ("--nosuccess".equals(args[i]) || "-q".equals(args[i])) {
quiet = true;
} else if ("--help".equals(args[i]) || "-h".equals(args[i])) {
usage();
return -1;
} else if (args[i].startsWith("-")) {
System.out.println("Unknown option: " + args[i]);
return EX_CMD_LINE_ERROR;
} else {
commands.add(args[i]);
}
++i;
}
return EX_SUCCESS;
}
/** Prints out the usage information */
public void usage() {
System.out.println("java org.smtlib.Driver [options] commands");
System.out.println(" -h or --help : prints out the usage information");
System.out.println(" -v or --verbose : enables printing of detailed progress information");
System.out.println(" -q or --nosuccess : disables printing the 'success' reponses");
System.out.println(" -p <number> or --port <number> : (required) specifies the port to which to send commands");
System.out.println(" The port must match the port on which the server process is listening");
System.out.println(" This process sends SMT-LIB commands (as specified on the command-line) to a");
System.out.println(" server process, which must be on the local host, and is started by ");
System.out.println(" 'java org.smtlib.SMT --port <number>' ");
System.out.println(" Each SMT command is a (quoted) single command-line argument.");
}
/** Sends the options and commands to the port; returns the exit code corresponding to the response
* from the last command. */
public int send() throws IOException {
/*@Mutable*/ Socket serverSocket = null;
/*@Mutable*/ PrintWriter out = null;
/*@Mutable*/ BufferedReader in = null;
try {
// FIXME - Inet6? Allow non-local host?
serverSocket = new Socket(Inet4Address.getLocalHost(), port);
out = new PrintWriter(serverSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(
serverSocket.getInputStream()));
int exitcode = -1;
for (String command: commands) {
if (verbose) System.out.println("send: " + command);
out.println(command);
do {
String answer = in.readLine();
if ("success".equals(answer)) exitcode = EX_SUCCESS;
else if ("sat".equals(answer)) exitcode = EX_SMT_SAT;
else if ("unsat".equals(answer)) exitcode = EX_SMT_UNSAT;
else if ("unknown".equals(answer)) exitcode = EX_SMT_UNKNOWN;
else if (answer.indexOf("error") != -1) exitcode = EX_SMT_ERROR;
else exitcode = EX_SMT_OTHER;
if (!quiet || verbose || exitcode != EX_SUCCESS) System.out.println("SMT: " + answer );
} while (in.ready());
}
if (verbose) System.out.println("exitcode = " + exitcode);
return exitcode;
} catch (UnknownHostException e) {
System.err.println("Failure to connect to local host: " + e);
return EX_EXCEPTION;
} catch (IOException e) {
System.err.println("Couldn't get I/O from the socket connection: " + e);
return EX_EXCEPTION;
} finally {
if (out != null) out.close();
if (in != null) in.close();
if (serverSocket != null) serverSocket.close();
}
}
}
|
[
"[email protected]"
] | |
20992e9d4159e2a52e10b89c351408f57862bfe9
|
0529524c95045b3232f6553d18a7fef5a059545e
|
/app/src/androidTest/java/TestCase_au_net_atfvision_app__912897552.java
|
910e42d64bc41e58884d0d35902e283ce8d14f3a
|
[] |
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 | 284 |
java
|
import androidx.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(AndroidJUnit4.class)
public class TestCase_au_net_atfvision_app__912897552 {
@Test
public void testCase() throws Exception {
// $FF: Couldn't be decompiled
}
}
|
[
"[email protected]"
] | |
3dbf2b6295012e6ca9bf5bb7fde67a374892f8af
|
5b7146d0e77f199cd5bb5504b175daef9556913a
|
/src/main/java/com/vankata/weeski/service/BlockedEmailServiceImpl.java
|
57a3acde951f9d5833894a25a958dd2781f21c6a
|
[] |
no_license
|
pashkulev/wee-ski-server
|
3bfec5d7eb57b1081aa43942469687be4fc81717
|
e20f126a2a413c97463b344eaf97c047f3d10a81
|
refs/heads/master
| 2020-03-26T15:11:52.453485 | 2018-09-10T15:42:41 | 2018-09-10T15:42:41 | 145,027,543 | 1 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,026 |
java
|
package com.vankata.weeski.service;
import com.vankata.weeski.domain.blockedEmail.model.BlockedEmail;
import com.vankata.weeski.repository.BlockedEmailRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Optional;
@Service
public class BlockedEmailServiceImpl implements BlockedEmailService {
private final BlockedEmailRepository blockedEmailRepository;
@Autowired
public BlockedEmailServiceImpl(BlockedEmailRepository blockedEmailRepository) {
this.blockedEmailRepository = blockedEmailRepository;
}
@Override
public boolean isEmailBlocked(String email) {
Optional<BlockedEmail> optionalBlockedEmail = this.blockedEmailRepository.findByEmail(email);
return optionalBlockedEmail.isPresent();
}
@Override
public void addBlockedEmail(String email) {
BlockedEmail blockedEmail = new BlockedEmail(email);
this.blockedEmailRepository.save(blockedEmail);
}
}
|
[
"[email protected]"
] | |
4d46ae43271f85102dae3d1adbd659738cb3ee35
|
47f6b62466bddda8b8ff3a9a00f61e975ca1872f
|
/OrcamentoApp/src/orcamentoapp/OrcamentoApp.java
|
04d0dc766ba6f2ca2ab0f7f72cc0d13ff8e46f2c
|
[] |
no_license
|
freddy556/lista2-LucasMendesSouza
|
7614ea2e80be5cddbab8c943bffc4c1913840d50
|
c0f18e43a808e4b8de190662d29994771369b298
|
refs/heads/main
| 2023-03-07T01:26:29.230249 | 2021-02-22T04:25:29 | 2021-02-22T04:25:29 | 341,027,166 | 0 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,933 |
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 orcamentoapp;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
/**
*
* @author max_p
*/
public class OrcamentoApp {
public static void main(String[] args) {
LocalTime horaAgora = LocalTime.now();
LocalDate dataHoje = LocalDate.now();
Mes m1 = Mes.MARCO;
Pessoa p1 = new Pessoa();
p1.setNome("Vance");
p1.setIdade(30);
p1.setRenda(1980.56);
p1.setGastos(3999.95);
p1.calculaRenda();
BigDecimal _renda = new BigDecimal("1980.56");
BigDecimal _gastos = new BigDecimal("3999.95");
BigDecimal _rendaMes = _renda.subtract(_gastos);
System.out.println(p1.getNome() + " - " + p1.getIdade()+ " anos");
System.out.println("Consulta referente ao mês de "+m1.toString() + " - " + m1.getValor());
System.out.println("Consulta realizada as " + horaAgora + " No dia " + dataHoje);
System.out.println("Valor total da renda no mês: R$"+ _rendaMes+"\n");
Pessoa p2 = new Pessoa();
p1.setNome("Oliver");
p1.setIdade(29);
p1.setRenda(31980.56);
p1.setGastos(23999.95);
p1.calculaRenda();
BigDecimal _renda1 = new BigDecimal("31980.56");
BigDecimal _gastos1 = new BigDecimal("23999.95");
BigDecimal _rendaMes1 = _renda1.subtract(_gastos1);
System.out.println(p1.getNome() + " - " + p1.getIdade()+ " anos");
System.out.println("Consulta referente ao mês de "+m1.toString() + " - " + m1.getValor());
System.out.println("Consulta realizada as " + horaAgora + " No dia " + dataHoje);
System.out.println("Valor total da renda no mês: R$"+ _rendaMes1+"\n");
}
}
|
[
"[email protected]"
] | |
0b99c59a0f67daae077eff4ae3e37e8e64d2ff77
|
09b7f281818832efb89617d6f6cab89478d49930
|
/root/modules/dod-5015/source/java/org/alfresco/module/org_alfresco_module_dod5015/notification/RecordsManagementNotificationService.java
|
4cb13d71223bd13cebdbb679d617f3fa91a2117d
|
[] |
no_license
|
verve111/alfresco3.4.d
|
54611ab8371a6e644fcafc72dc37cdc3d5d8eeea
|
20d581984c2d22d5fae92e1c1674552c1427119b
|
refs/heads/master
| 2023-02-07T14:00:19.637248 | 2020-12-25T10:19:17 | 2020-12-25T10:19:17 | 323,932,520 | 1 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,516 |
java
|
/*
* Copyright (C) 2009-2010 Alfresco Software Limited.
*
* This file is part of Alfresco
*
* Alfresco is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Alfresco is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/
package org.alfresco.module.org_alfresco_module_dod5015.notification;
import java.util.Map;
import java.util.Set;
import org.alfresco.service.cmr.repository.NodeRef;
/**
* Records Management Notification Service
*
* @author Roy Wetherall
*/
public interface RecordsManagementNotificationService
{
/** TODO Temporary constants */
public static final String NT_EMAIL = "email";
public static final String NE_DUE_FOR_REVIEW = "dueForReview";
public static final String NE_SUPERSEDED = "superseded";
/**
* Get notification events
*
* @return
*/
Set<String> getNotificationEvents();
/**
* Get notification types
*
* @return
*/
Set<String> getNotificationTypes();
/**
* Send notification to user
*
* @param notificationEvent
* @param notificationType
* @param userName
* @param notificationData
*/
void sendNotificationToUser(String notificationEvent, String notificationType, String userName, Map<String, Object> notificationData);
/**
* Send notification to group
*
* @param notificationEvent
* @param notificationType
* @param groupName
* @param notificationData
*/
void sendNotificationToGroup(String notificationEvent, String notificationType, String groupName, Map<String, Object> notificationData);
/**
* Send notification to role
*
* @param notificationEvent
* @param notificationType
* @param rmRootNode
* @param roleName
* @param notificationData
*/
void sendNotificationToRole(String notificationEvent, String notificationType, NodeRef rmRootNode, String roleName, Map<String, Object> notificationData);
}
|
[
"[email protected]"
] | |
2a132eb6504172464ba7cb05b101f2547e06dc8a
|
8cd0d6ca4e70936fd5ea8c089f9c0b8c44ff664e
|
/src/main/java/hxDaedalus/iterators/FromMeshToVertices.java
|
2e1bee9a88190af33f06c8a989ca8173a522b1a3
|
[
"MIT"
] |
permissive
|
taluks/jwalkable
|
b7cc84f451d3cde016d0a26b7d3f3d5dc7adadcc
|
8ffaaf355816aa0aecf72055b56652b3f7b3b44b
|
refs/heads/master
| 2023-06-22T05:12:03.390871 | 2021-07-23T02:31:18 | 2021-07-23T02:31:18 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | true | 15,770 |
java
|
// Generated by Haxe 3.4.2
package hxDaedalus.iterators;
import haxe.root.*;
@SuppressWarnings(value={"rawtypes", "unchecked"})
public class FromMeshToVertices extends haxe.lang.HxObject
{
public FromMeshToVertices(haxe.lang.EmptyObject empty)
{
}
public FromMeshToVertices()
{
//line 13 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
hxDaedalus.iterators.FromMeshToVertices.__hx_ctor_hxDaedalus_iterators_FromMeshToVertices(this);
}
public static void __hx_ctor_hxDaedalus_iterators_FromMeshToVertices(hxDaedalus.iterators.FromMeshToVertices __hx_this)
{
}
public hxDaedalus.data.Mesh _fromMesh;
public int _currIndex;
public hxDaedalus.data.Vertex _resultVertex;
public hxDaedalus.data.Mesh set_fromMesh(hxDaedalus.data.Mesh value)
{
//line 16 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._fromMesh = value;
//line 17 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._currIndex = 0;
//line 18 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return value;
}
public hxDaedalus.data.Vertex next()
{
//line 22 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
while (true)
{
//line 23 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (( this._currIndex < this._fromMesh._vertices.length ))
{
//line 24 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._resultVertex = this._fromMesh._vertices.__get(this._currIndex);
//line 25 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._currIndex++;
}
else
{
//line 27 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._resultVertex = null;
//line 28 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
//line 22 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if ( ! (( ! (this._resultVertex.get_isReal()) )) )
{
//line 22 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
}
//line 31 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return this._resultVertex;
}
@Override public double __hx_setField_f(java.lang.String field, double value, boolean handleProperties)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
boolean __temp_executeDef1 = true;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
switch (field.hashCode())
{
case -857179071:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_currIndex"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._currIndex = ((int) (value) );
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return value;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (__temp_executeDef1)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return super.__hx_setField_f(field, value, handleProperties);
}
else
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
throw null;
}
}
}
@Override public java.lang.Object __hx_setField(java.lang.String field, java.lang.Object value, boolean handleProperties)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
boolean __temp_executeDef1 = true;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
switch (field.hashCode())
{
case -1844345344:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_resultVertex"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._resultVertex = ((hxDaedalus.data.Vertex) (value) );
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return value;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -1244873545:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("fromMesh"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this.set_fromMesh(((hxDaedalus.data.Mesh) (value) ));
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return value;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -857179071:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_currIndex"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._currIndex = ((int) (haxe.lang.Runtime.toInt(value)) );
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return value;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -1154355690:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_fromMesh"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
this._fromMesh = ((hxDaedalus.data.Mesh) (value) );
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return value;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (__temp_executeDef1)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return super.__hx_setField(field, value, handleProperties);
}
else
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
throw null;
}
}
}
@Override public java.lang.Object __hx_getField(java.lang.String field, boolean throwErrors, boolean isCheck, boolean handleProperties)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
boolean __temp_executeDef1 = true;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
switch (field.hashCode())
{
case 3377907:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("next"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return ((haxe.lang.Function) (new haxe.lang.Closure(this, "next")) );
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -1154355690:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_fromMesh"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return this._fromMesh;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -1618935820:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("set_fromMesh"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return ((haxe.lang.Function) (new haxe.lang.Closure(this, "set_fromMesh")) );
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -857179071:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_currIndex"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return this._currIndex;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -1844345344:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_resultVertex"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return this._resultVertex;
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (__temp_executeDef1)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return super.__hx_getField(field, throwErrors, isCheck, handleProperties);
}
else
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
throw null;
}
}
}
@Override public double __hx_getField_f(java.lang.String field, boolean throwErrors, boolean handleProperties)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
boolean __temp_executeDef1 = true;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
switch (field.hashCode())
{
case -857179071:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("_currIndex"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return ((double) (this._currIndex) );
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (__temp_executeDef1)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return super.__hx_getField_f(field, throwErrors, handleProperties);
}
else
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
throw null;
}
}
}
@Override public java.lang.Object __hx_invokeField(java.lang.String field, haxe.root.Array dynargs)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
boolean __temp_executeDef1 = true;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
switch (field.hashCode())
{
case 3377907:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("next"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return this.next();
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
case -1618935820:
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (field.equals("set_fromMesh"))
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
__temp_executeDef1 = false;
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return this.set_fromMesh(((hxDaedalus.data.Mesh) (dynargs.__get(0)) ));
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
break;
}
}
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
if (__temp_executeDef1)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
return super.__hx_invokeField(field, dynargs);
}
else
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
throw null;
}
}
}
@Override public void __hx_getFields(haxe.root.Array<java.lang.String> baseArr)
{
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
baseArr.push("_resultVertex");
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
baseArr.push("_currIndex");
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
baseArr.push("_fromMesh");
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
baseArr.push("fromMesh");
//line 7 "/Users/tao/projects/hxDaedalus/src/hxDaedalus/iterators/FromMeshToVertices.hx"
super.__hx_getFields(baseArr);
}
}
|
[
"[email protected]"
] | |
f0b16e1fc26f8af0df472bd9d67cc217f0987584
|
a13c5764f2d1a163d39e009c9841330b8eb6730f
|
/src/main/java/com/nssol/web/util/role/RoleUtil.java
|
2e3a99edd0775d34654116b7f52fada40ce5654c
|
[] |
no_license
|
yuanshuangqi/NSSOL_NEWRFID
|
43f942eb52fd015cdefe2d016d44653d2318cad2
|
041d59509d8c5581fee204ab5c8513815fe82db2
|
refs/heads/master
| 2022-07-10T00:19:00.910212 | 2020-03-02T05:32:33 | 2020-03-02T05:32:33 | 244,288,355 | 0 | 0 | null | 2022-06-17T02:55:29 | 2020-03-02T05:30:59 |
Java
|
UTF-8
|
Java
| false | false | 875 |
java
|
package com.nssol.web.util.role;
import cn.hutool.core.collection.CollUtil;
import com.nssol.web.system.model.RoleInfo;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
@Component
public class RoleUtil {
/**
* 递归封装子角色
* @param parentRole
* @param roles
* @return
*/
public static List<RoleInfo> getChildren(RoleInfo parentRole, List<RoleInfo> roles) {
List<RoleInfo> children = new ArrayList<>();
for (RoleInfo role : roles) {
if(role.getParentId().equals(parentRole.getId())){
children.add(role);
}
}
if(CollUtil.isNotEmpty(children)){
for (RoleInfo child : children) {
child.setChildren(getChildren(child,roles));
}
}
return children;
}
}
|
[
"[email protected]"
] | |
ae0e71f0928d3b352785169a0bc590dc61afabd7
|
08876e206c18fc0cbb6e555efba48e24f94a4dfb
|
/Android/EasyBudget/app/src/main/java/com/benoitletondor/easybudgetapp/view/SettingsActivity.java
|
3d92e19e08219eeb82673c2c344ce4cfa762df0e
|
[
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] |
permissive
|
yousafgill/EasyBudget
|
17140fc2fd1928f7daf2223219eaa50170ee2865
|
47cdc64d3b45ec0f3803726ce92cc27dcd6548b3
|
refs/heads/master
| 2020-06-17T15:18:01.599256 | 2019-06-08T15:43:16 | 2019-06-08T15:43:16 | 195,961,292 | 1 | 0 |
Apache-2.0
| 2019-07-09T07:59:30 | 2019-07-09T07:59:30 | null |
UTF-8
|
Java
| false | false | 2,725 |
java
|
/*
* Copyright 2015 Benoit LETONDOR
*
* 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.benoitletondor.easybudgetapp.view;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import androidx.appcompat.app.AppCompatActivity;
import android.view.MenuItem;
import com.benoitletondor.easybudgetapp.R;
import java.util.Objects;
/**
* Activity that displays settings using the {@link PreferencesFragment}
*
* @author Benoit LETONDOR
*/
public class SettingsActivity extends AppCompatActivity
{
/**
* Key to specify that the premium popup should be shown to the user
*/
public static final String SHOW_PREMIUM_INTENT_KEY = "showPremium";
/**
* Intent action broadcast when the user has successfully completed the {@link PremiumActivity}
*/
public static final String USER_GONE_PREMIUM_INTENT = "user.ispremium";
/**
* Request code used by premium activity
*/
protected static final int PREMIUM_ACTIVITY = 20020;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_settings);
Objects.requireNonNull(getSupportActionBar()).setDisplayShowHomeEnabled(true);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item)
{
int id = item.getItemId();
if( id == android.R.id.home ) // Back button of the actionbar
{
finish();
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data)
{
super.onActivityResult(requestCode, resultCode, data);
if( requestCode == PREMIUM_ACTIVITY )
{
if( resultCode == Activity.RESULT_OK )
{
LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(USER_GONE_PREMIUM_INTENT));
}
}
}
}
|
[
"[email protected]"
] | |
790b6fa6b42e31a21aabcc10296b06c774719122
|
5e3333e91324ae7add5b25f9d8b263ffb4429ad1
|
/web02/src/main/java/sems/dao/SubjectDao.java
|
451a23bafdc83b374f0a8fd915a4d9d3cb6073f3
|
[] |
no_license
|
Ratist/web02
|
8108f9d17121f35c5283af54f21682b442272e31
|
c149e821ff106bc0a7b4bf9077ffcd85de34ff43
|
refs/heads/master
| 2020-05-28T06:39:56.288041 | 2014-05-22T02:33:43 | 2014-05-22T02:33:43 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 390 |
java
|
package sems.dao;
import java.util.List;
import java.util.Map;
import sems.vo.SubjectVo;
public interface SubjectDao {
void insert(SubjectVo subject) throws Throwable;
List<SubjectVo> list(Map<String, Integer> params) throws Throwable;
SubjectVo detail(int no) throws Throwable;
void update(SubjectVo subject) throws Throwable;
void delete(int no) throws Throwable;
}
|
[
"[email protected]"
] | |
f5ebea4774d98184daf51f884ed14ee1afe21c76
|
bed4d693cbf95021c7946bb947394f2588619519
|
/main/src/com/google/refine/importers/TabularImportingParserBase.java
|
fd93832424f1e791ef03d5357ba634e5647cbc17
|
[
"BSD-3-Clause"
] |
permissive
|
parag2502/sierratool
|
821234bbcefc6f5ca114d2568ccbddd8018c8ea3
|
f51c387538720817974fd26db33e4ea009ca4920
|
refs/heads/master
| 2022-10-13T18:31:38.398979 | 2020-04-30T09:22:19 | 2020-04-30T09:22:19 | 219,942,363 | 0 | 0 |
BSD-3-Clause
| 2022-09-08T01:03:48 | 2019-11-06T07:59:06 |
Java
|
UTF-8
|
Java
| false | false | 9,249 |
java
|
/*
Copyright 2011, Google Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.google.refine.importers;
import java.io.IOException;
import java.io.Reader;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.refine.ProjectMetadata;
import com.google.refine.expr.ExpressionUtils;
import com.google.refine.importing.ImportingJob;
import com.google.refine.model.Cell;
import com.google.refine.model.Column;
import com.google.refine.model.Project;
import com.google.refine.model.Row;
import com.google.refine.util.JSONUtilities;
abstract public class TabularImportingParserBase extends ImportingParserBase {
static public interface TableDataReader {
public List<Object> getNextRowOfCells() throws IOException;
}
@Override
public ObjectNode createParserUIInitializationData(ImportingJob job,
List<ObjectNode> fileRecords, String format) {
ObjectNode options = super.createParserUIInitializationData(job, fileRecords, format);
JSONUtilities.safePut(options, "ignoreLines", -1); // number of blank lines at the beginning to ignore
JSONUtilities.safePut(options, "headerLines", 1); // number of header lines
JSONUtilities.safePut(options, "skipDataLines", 0); // number of initial data lines to skip
JSONUtilities.safePut(options, "storeBlankRows", true);
JSONUtilities.safePut(options, "storeBlankCellsAsNulls", true);
return options;
}
/**
* @param useInputStream true if parser takes an InputStream, false if it takes a Reader.
*
*/
protected TabularImportingParserBase(boolean useInputStream) {
super(useInputStream);
}
static public void readTable(
Project project,
ProjectMetadata metadata,
ImportingJob job,
TableDataReader reader,
String fileSource,
int limit,
ObjectNode options,
List<Exception> exceptions
) {
int ignoreLines = JSONUtilities.getInt(options, "ignoreLines", -1);
int headerLines = JSONUtilities.getInt(options, "headerLines", 1);
int skipDataLines = JSONUtilities.getInt(options, "skipDataLines", 0);
int limit2 = JSONUtilities.getInt(options, "limit", -1);
if (limit > 0) {
if (limit2 > 0) {
limit2 = Math.min(limit, limit2);
} else {
limit2 = limit;
}
}
boolean guessCellValueTypes = JSONUtilities.getBoolean(options, "guessCellValueTypes", false);
boolean storeBlankRows = JSONUtilities.getBoolean(options, "storeBlankRows", true);
boolean storeBlankCellsAsNulls = JSONUtilities.getBoolean(options, "storeBlankCellsAsNulls", true);
boolean includeFileSources = JSONUtilities.getBoolean(options, "includeFileSources", false);
int filenameColumnIndex = -1;
if (includeFileSources) {
filenameColumnIndex = addFilenameColumn(project);
}
List<String> columnNames = new ArrayList<String>();
boolean hasOurOwnColumnNames = headerLines > 0;
List<Object> cells = null;
int rowsWithData = 0;
try {
while (!job.canceled && (cells = reader.getNextRowOfCells()) != null) {
if (ignoreLines > 0) {
ignoreLines--;
continue;
}
if (headerLines > 0) { // header lines
for (int c = 0; c < cells.size(); c++) {
Object cell = cells.get(c);
String columnName;
if (cell == null) {
// add column even if cell is blank
columnName = "";
} else if (cell instanceof Cell) {
columnName = ((Cell) cell).value.toString().trim();
} else {
columnName = cell.toString().trim();
}
ImporterUtilities.appendColumnName(columnNames, c, columnName);
}
headerLines--;
if (headerLines == 0) {
ImporterUtilities.setupColumns(project, columnNames);
}
} else { // data lines
Row row = new Row(columnNames.size());
if (storeBlankRows) {
rowsWithData++;
} else if (cells.size() > 0) {
rowsWithData++;
}
if (skipDataLines <= 0 || rowsWithData > skipDataLines) {
boolean rowHasData = false;
for (int c = 0; c < cells.size(); c++) {
Column column = ImporterUtilities.getOrAllocateColumn(
project, columnNames, c, hasOurOwnColumnNames);
Object value = cells.get(c);
if (value instanceof Cell) {
row.setCell(column.getCellIndex(), (Cell) value);
rowHasData = true;
} else if (ExpressionUtils.isNonBlankData(value)) {
Serializable storedValue;
if (value instanceof String) {
storedValue = guessCellValueTypes ?
ImporterUtilities.parseCellValue((String) value) : (String) value;
} else {
storedValue = ExpressionUtils.wrapStorable(value);
}
row.setCell(column.getCellIndex(), new Cell(storedValue, null));
rowHasData = true;
} else if (!storeBlankCellsAsNulls) {
row.setCell(column.getCellIndex(), new Cell("", null));
} else {
row.setCell(column.getCellIndex(), null);
}
}
if (rowHasData || storeBlankRows) {
if (includeFileSources && filenameColumnIndex >= 0) {
row.setCell(
filenameColumnIndex,
new Cell(fileSource, null));
}
project.rows.add(row);
}
if (limit2 > 0 && project.rows.size() >= limit2) {
break;
}
}
}
}
} catch (IOException e) {
exceptions.add(e);
}
}
public void parseOneFile(Project project, ProjectMetadata metadata, ImportingJob job, String fileSource,
Reader dataReader, int limit, ObjectNode options, List<Exception> exceptions) {
super.parseOneFile(project, metadata, job, fileSource, dataReader, limit, options, exceptions);
}
}
|
[
"[email protected]"
] | |
9a1a61f04fb69cd5cda8c5f9facf2c8af5f391a4
|
2ac1a9cf4b8a59f784206f218d601874fe1b01cf
|
/gear-monitor/gear-monitor-core/src/test/java/cn/howardliu/gear/monitor/core/os/OsProbeTest.java
|
4945bcf8d8d144df9e2b4537ec2e6ab001d8ffe3
|
[
"Apache-2.0"
] |
permissive
|
howardliu-cn/my-gear
|
a173911c2997ddcabfcd72dd929aa7e22a28bc37
|
e81448ed01964b5d6f30cfbf36afd6f7b66c78be
|
refs/heads/master
| 2022-12-21T00:22:06.925972 | 2020-05-05T15:12:58 | 2020-05-05T15:12:58 | 74,741,047 | 1 | 2 |
Apache-2.0
| 2022-12-16T07:29:21 | 2016-11-25T08:48:57 |
Java
|
UTF-8
|
Java
| false | false | 1,203 |
java
|
package cn.howardliu.gear.monitor.core.os;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertTrue;
/**
* <br>created at 17-5-4
*
* @author liuxh
* @version 1.0.0
* @since 1.0.0
*/
public class OsProbeTest {
private OsProbe probe;
@Before
public void setUp() throws Exception {
probe = new OsProbe();
}
@Test
public void getCommittedVirtualMemorySize() throws Exception {
}
@Test
public void getTotalSwapSpaceSize() throws Exception {
}
@Test
public void getFreeSwapSpaceSize() throws Exception {
}
@Test
public void getProcessCpuTime() throws Exception {
}
@Test
public void getFreePhysicalMemorySize() throws Exception {
}
@Test
public void getTotalPhysicalMemorySize() throws Exception {
}
@Test
public void getSystemCpuLoad() throws Exception {
}
@Test
public void getSystemLoadAverage() throws Exception {
}
@Test
public void readProcLoadavg() throws Exception {
}
@Test
public void getSystemCpuPercent() throws Exception {
}
@Test
public void getProcessCpuLoad() throws Exception {
}
}
|
[
"[email protected]"
] | |
ee3bb611a8c4f4ff10ce03b91e6f8945154e61f9
|
2c15fd17fd198e53f925e4b39cd1e954684882d5
|
/src/pattern/command/example1/Command.java
|
645e228344296263b1ba16b6abb0c83c913281e9
|
[] |
no_license
|
chevro-lee/oop-desigin-pattern
|
13f3434dd498f27d21e90bb4ae6fd6ff6d88a97d
|
7ec7110ddc47c109f16c56fa8915cf4805252c8d
|
refs/heads/master
| 2023-06-19T07:34:58.016496 | 2021-07-07T09:24:53 | 2021-07-07T09:24:53 | 378,070,299 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 310 |
java
|
package pattern.command.example1;
/**
* Author li.ling
* Description 抽象命令类
* Date 2021/6/28 10:23
*/
public abstract class Command {
protected IBarbecuer barbecuer;
public Command(IBarbecuer iBarbecuer) {
barbecuer = iBarbecuer;
}
protected abstract void execute();
}
|
[
"[email protected]"
] | |
4fb019f97069de381adecc6b9179b0dfab4e2d3e
|
dc0fa63827eaa38768d7d00cabe5381e0424d20d
|
/Domaci3Servleti/Domaci3/src/java/FormaServlet/Servlet.java
|
a7a5a3056282dad80f255a1e7dea89a6691f05f2
|
[] |
no_license
|
milicadodevski/DomaciZadatakServlet
|
263de7b56c506b6b333319f73faa38b2f1d710dd
|
bbd1d64abbc95eec9a0fd5f7eeecf151fa118460
|
refs/heads/master
| 2020-04-06T10:39:26.132668 | 2018-11-13T13:48:27 | 2018-11-13T13:48:27 | 157,387,309 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 3,142 |
java
|
package FormaServlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Servlet extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
String ime = request.getParameter("ime");
String adresa = request.getParameter("adresa");
String mail = request.getParameter("e-mail");
String predznanje = request.getParameter("predznanje");
String telefon = request.getParameter("telefon");
String zanimanje = request.getParameter("zanimanje");
String napomena = request.getParameter("napomena");
PrintWriter out = response.getWriter();
try {
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Do servleta su stigli sledeci podaci: </h1>");
out.println("Ime: " + ime);
out.println("<br><br> Adresa: " + adresa);
out.println("<br><br>E-mail: " + mail);
out.println("<br><br>Predznanje: " + predznanje);
out.println("<br><br>Telefon: " + telefon);
out.println("<br><br>Zanimanje: " + zanimanje);
out.println("<br><br>Napomena: " + napomena);
out.println("</body>");
out.println("</html>");
}
finally{
out.close();
}
}
// <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
/**
* Handles the HTTP <code>GET</code> method.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
/**
* Handles the HTTP <code>POST</code> method.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
/**
* Returns a short description of the servlet.
*
* @return a String containing servlet description
*/
@Override
public String getServletInfo() {
return "Short description";
}// </editor-fold>
}
|
[
"[email protected]"
] | |
67b6d401ffe31f1776c2959400f2e26bc979b9a3
|
917d7bd1606cbe11b21844be6aa85d23daf04bda
|
/Two_Factor/TwoFactorCloud/src/com/Decentralized/action/SecretAction.java
|
d8dc2e5de205d65beabfebe01a6e0261f417485e
|
[] |
no_license
|
jnammu21/JavaProject
|
f635ff1d0a4fcdf79cc6bd8c504ee9f2e0a5742c
|
a2f3464b7d1754e75509eb6ac5c654d8494d64b3
|
refs/heads/master
| 2020-03-25T21:58:21.566279 | 2018-08-09T20:01:30 | 2018-08-09T20:01:30 | 144,198,316 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,191 |
java
|
package com.Decentralized.action;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.Decentralized.bean.FileTo;
import com.Decentralized.dao.UserdaoImpl;
import com.sun.org.apache.commons.beanutils.BeanUtils;
public class SecretAction extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
FileTo rto = new FileTo();
Map map = request.getParameterMap();
try {
BeanUtils.populate(rto, map);
} catch (IllegalAccessException e1) {
e1.printStackTrace();
} catch (InvocationTargetException e1) {
e1.printStackTrace();
}
String path = "";
String userrole = "";
boolean flag = false;
HttpSession s=request.getSession();
String login=(String) s.getAttribute("UserName");
String lid=request.getParameter("skey");
System.out.println(" username from session is "+login);
System.out.println(" lid from session is "+lid);
rto.setUsername(login);
String role=null;
try
{
flag= new UserdaoImpl().deleteMatrix();
flag= new UserdaoImpl().insertMatrix(login);
userrole= new UserdaoImpl().viewRole(login);
s.setAttribute("userrole", userrole);
System.out.println(flag);
role= new UserdaoImpl().getLid(login,lid);
System.out.println(role);
if (role!=null) {
request.setAttribute("status","Your Secret Key is Correct");
path = "./verifyhash.jsp";
} else {
request.setAttribute("status1","");
path = "./verifyhash.jsp";
}
} catch (Exception e) {
request.setAttribute("status"," Please Enter Valid File");
path = "./verifyhash.jsp";
}
RequestDispatcher rd = request.getRequestDispatcher(path);
rd.forward(request, response);
}
}
|
[
"[email protected]"
] | |
986fe3a4caf145976c72cf77f5e98aec24ebc77d
|
6d32896ea593dece22ae3cb5961888f070a01d2b
|
/beer_api_digital_innovation_one-master/src/main/java/one/digitalinnovation/beerstock/service/BeerService.java
|
aa3be7d6ed8428121bf97de6b8f3760466762381
|
[] |
no_license
|
DiegoDBLe/Projeto_BeerStock
|
c609a989365ec1697e4d7311d485e49b4475915e
|
d8e59f8490476f78b4da725a3507b9e7c8b629d8
|
refs/heads/master
| 2023-06-12T04:55:36.667084 | 2021-07-06T20:55:55 | 2021-07-06T20:55:55 | 383,594,963 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 3,012 |
java
|
package one.digitalinnovation.beerstock.service;
import lombok.AllArgsConstructor;
import one.digitalinnovation.beerstock.dto.BeerDTO;
import one.digitalinnovation.beerstock.entity.Beer;
import one.digitalinnovation.beerstock.exception.BeerAlreadyRegisteredException;
import one.digitalinnovation.beerstock.exception.BeerNotFoundException;
import one.digitalinnovation.beerstock.exception.BeerStockExceededException;
import one.digitalinnovation.beerstock.mapper.BeerMapper;
import one.digitalinnovation.beerstock.repository.BeerRepository;
import org.mockito.Mock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@Service
@AllArgsConstructor(onConstructor = @__ ( @Autowired ))
public class BeerService {
private final BeerRepository beerRepository;
private final BeerMapper beerMapper = BeerMapper.INSTANCE;
public BeerDTO createBeer(BeerDTO beerDTO) throws BeerAlreadyRegisteredException {
verifyIfIsAlreadyRegistered(beerDTO.getName());
Beer beer = beerMapper.toModel(beerDTO);
Beer savedBeer = beerRepository.save(beer);
return beerMapper.toDTO(savedBeer);
}
public BeerDTO findByName(String name) throws BeerNotFoundException {
Beer foundBeer = beerRepository.findByName(name)
.orElseThrow(() -> new BeerNotFoundException(name));
return beerMapper.toDTO(foundBeer);
}
public List<BeerDTO> listAll() {
return beerRepository.findAll()
.stream()
.map(beerMapper::toDTO)
.collect(Collectors.toList());
}
public void deleteById(Long id) throws BeerNotFoundException {
verifyIfExists(id);
beerRepository.deleteById(id);
}
private void verifyIfIsAlreadyRegistered(String name) throws BeerAlreadyRegisteredException {
Optional<Beer> optSavedBeer = beerRepository.findByName(name);
if (optSavedBeer.isPresent()) {
throw new BeerAlreadyRegisteredException(name);
}
}
private Beer verifyIfExists(Long id) throws BeerNotFoundException {
return beerRepository.findById(id)
.orElseThrow(() -> new BeerNotFoundException(id));
}
public BeerDTO increment(Long id, int quantityToIncrement) throws BeerNotFoundException, BeerStockExceededException {
Beer beerToIncrementStock = verifyIfExists(id);
int quantityAfterIncrement = quantityToIncrement + beerToIncrementStock.getQuantity();
if (quantityAfterIncrement <= beerToIncrementStock.getMax()) {
beerToIncrementStock.setQuantity(beerToIncrementStock.getQuantity() + quantityToIncrement);
Beer incrementedBeerStock = beerRepository.save(beerToIncrementStock);
return beerMapper.toDTO(incrementedBeerStock);
}
throw new BeerStockExceededException(id, quantityToIncrement);
}
}
|
[
"[email protected]"
] | |
716cdb69ffb20a1d08ea32a232ab9d05fbf62ec2
|
75166b7f380adc536efc8f05f74f39b0b15ad566
|
/src/main/java/com/rfm/rfmApi/dataFetcher/AllocationDataFetcher.java
|
5074a30712c4bdd80ad60bc32331155405127de2
|
[] |
no_license
|
BoopathySamayamuthu/graphQL
|
d25ce0fea8d5a4ad4f170511374aacbd27280d98
|
ccda3aaf3ada5a801b5f184e9dad556b6c9772d4
|
refs/heads/master
| 2022-11-24T09:05:27.888306 | 2020-01-02T20:11:36 | 2020-01-02T20:11:36 | 231,446,859 | 0 | 0 | null | 2022-11-16T08:57:53 | 2020-01-02T19:33:15 |
Java
|
UTF-8
|
Java
| false | false | 708 |
java
|
package com.rfm.rfmApi.dataFetcher;
import com.rfm.rfmApi.entities.AllocationData;
import graphql.schema.DataFetcher;
import graphql.schema.DataFetchingEnvironment;
import java.util.Map;
import org.springframework.stereotype.Component;
/**
* @author n0217055
*
*/
@Component
public class AllocationDataFetcher implements DataFetcher<AllocationData> {
@Override
public AllocationData get(DataFetchingEnvironment env) {
Map args = env.getArguments();
String ctsEmpID = String.valueOf(args.get("ctsEmpID"));
AllocationData allocationData = new AllocationData();
allocationData.setCtsEmpID(ctsEmpID);
return allocationData;
}
}
|
[
"[email protected]"
] | |
7c37b79a461a3c039076ec886d70610e4b706aa0
|
5a30075cd5fb0b985f2837afd9f03a62986ec8fb
|
/src/main/java/his/TherapyCalendar.java
|
a2f705369ac7b253b18189753b2404abd3f0696b
|
[] |
no_license
|
Untar1/SM_2
|
052e33d1004d70d6d54ce1f88a75aff1dbc791d2
|
9c9a2bc23f18bad4cbafc693bbfda8025832fe7f
|
refs/heads/master
| 2020-04-07T08:19:31.398642 | 2018-11-19T21:15:21 | 2018-11-19T21:15:21 | 158,208,966 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 188 |
java
|
/**
* @(#) TherapyCalendar.java
*/
package his;
public class TherapyCalendar extends Calendar
{
private DayHospitalTheraphy therapy;
private HospitalTherapy hospitalTherapy;
}
|
[
"[email protected]"
] | |
3ef485b9fe534e8fe0630acb2e1be114f7781470
|
fc05322703594e40548f8e738449b9418efb7518
|
/src/main/java/org/basex/query/func/fn/FnExactlyOne.java
|
a7196f5af05fffffaa6cfd71fe56721dc72cbc23
|
[] |
no_license
|
mauricioscastro/basex-lmdb
|
0028994871be99ec1f5d86738adfad18983d3046
|
bb8f32b800cb0f894c398c0019bc501196a1a801
|
refs/heads/master
| 2021-01-21T00:08:36.905964 | 2017-09-26T17:39:31 | 2017-09-26T17:39:31 | 41,042,448 | 1 | 1 | null | 2017-09-26T14:58:24 | 2015-08-19T15:24:11 |
Java
|
UTF-8
|
Java
| false | false | 990 |
java
|
package org.basex.query.func.fn;
import static org.basex.query.QueryError.*;
import org.basex.query.*;
import org.basex.query.expr.*;
import org.basex.query.func.*;
import org.basex.query.iter.*;
import org.basex.query.value.item.*;
import org.basex.query.value.type.*;
import org.basex.query.var.*;
import org.basex.util.*;
/**
* Function implementation.
*
* @author BaseX Team 2005-15, BSD License
* @author Christian Gruen
*/
public final class FnExactlyOne extends StandardFunc {
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
final Iter ir = exprs[0].iter(qc);
final Item it = ir.next();
if(it == null || ir.next() != null) throw EXACTLYONE.get(info);
return it;
}
@Override
protected Expr opt(final QueryContext qc, final VarScope scp) {
final Expr e = exprs[0];
final SeqType st = e.seqType();
if(st.one()) return e;
seqType = SeqType.get(st.type, seqType.occ);
return this;
}
}
|
[
"[email protected]"
] | |
09eb0c2aa723797a4a10fe935ed943ca0c7fe479
|
a255668e97f6354d18216eef45d123322d78f10a
|
/src/main/java/com/magirui/genericitytt/genercityarray/GenercityArrayL1.java
|
93ac6c2849593dbfc1a6a39ef8116c8292bde508
|
[] |
no_license
|
MagiRui/java-learning
|
632269eb07ff35d6b55834923a2b323d345bf5d6
|
943f9ee56f937a156d54b12853a3d0d50ede9af0
|
refs/heads/main
| 2023-05-31T14:26:52.279210 | 2021-06-21T00:23:14 | 2021-06-21T00:23:14 | 377,722,122 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 503 |
java
|
package com.magirui.genericitytt.genercityarray;
import java.util.ArrayList;
import java.util.List;
/**
* @author MagiRui
* @description
* @date 6/16/21
*/
public class GenercityArrayL1 {
/*List<String>[] list11 = new ArrayList<String>[10];
List<String>[] list12 = new ArrayList<?>[10];
List<String>[] list13 = (List<String>[])new ArrayList<?>[10];
List<?>[] list14 = new ArrayList<String>[10];
List<?>[] list15 = new ArrayList<?>[10];
List<String>[] list6 = new ArrayList[10];*/
}
|
[
"[email protected]"
] | |
e8f97a5c4e786859a2dd4c05cf87d2b4f318f7cf
|
130ab40dc911846095ab17d21c8e4a3c405ddd4d
|
/gradleIntro/examples-20141105/chapter08/parallel-execution/src/test/java/com/example/a/F_ExampleBeanTest.java
|
0d7711d0a468950785dcbd0374647873159bb411
|
[] |
no_license
|
kagoshin/tutorial
|
ea3cc3436209df7b40ebfe481d610b71601e3f87
|
7f22fb3ace1152e98bcd724730e0776e008a2871
|
refs/heads/master
| 2023-08-22T20:44:05.808442 | 2023-08-13T15:26:38 | 2023-08-13T15:26:38 | 96,262,625 | 0 | 0 | null | 2023-08-30T06:10:13 | 2017-07-05T00:55:03 |
JavaScript
|
UTF-8
|
Java
| false | false | 1,818 |
java
|
package com.example.a;
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.assertThat;
import org.junit.Before;
import org.junit.Test;
import com.example.ExampleBean;
import com.example.StressBase;
public class F_ExampleBeanTest extends StressBase {
private ExampleBean testee = new ExampleBean("testing with stress");
@Before
public void setUp() {
stress();
}
@Test
public void doSomethingTest_01() {
testee.setValue("01");
assertThat(testee.getBeanValue(), is("testing with stress : 01"));
}
@Test
public void doSomethingTest_02() {
testee.setValue("02");
assertThat(testee.getBeanValue(), is("testing with stress : 02"));
}
@Test
public void doSomethingTest_03() {
testee.setValue("03");
assertThat(testee.getBeanValue(), is("testing with stress : 03"));
}
@Test
public void doSomethingTest_04() {
testee.setValue("04");
assertThat(testee.getBeanValue(), is("testing with stress : 04"));
}
@Test
public void doSomethingTest_05() {
testee.setValue("05");
assertThat(testee.getBeanValue(), is("testing with stress : 05"));
}
@Test
public void doSomethingTest_06() {
testee.setValue("06");
assertThat(testee.getBeanValue(), is("testing with stress : 06"));
}
@Test
public void doSomethingTest_07() {
testee.setValue("07");
assertThat(testee.getBeanValue(), is("testing with stress : 07"));
}
@Test
public void doSomethingTest_08() {
testee.setValue("08");
assertThat(testee.getBeanValue(), is("testing with stress : 08"));
}
@Test
public void doSomethingTest_09() {
testee.setValue("09");
assertThat(testee.getBeanValue(), is("testing with stress : 09"));
}
@Test
public void doSomethingTest_10() {
testee.setValue("10");
assertThat(testee.getBeanValue(), is("testing with stress : 10"));
}
}
|
[
"[email protected]"
] | |
842a5e396da07d7af3b3c59d9eb354adb58863b2
|
3ce571d0f68fadb8c930b83774af77eb9e14eacb
|
/ERPProjectDemo/src/main/java/com/netcracker/project/controllers/TaskController.java
|
45f47a72122e15a6eba85d572114dbeeac47b319
|
[] |
no_license
|
MikhailovOlegM/NC_ERP_app
|
af3ed6f9f74aa79ffd522ab4e46f7a0ed041239d
|
65d5e935e42c318301a38f2902ef9e0e03f2ea69
|
refs/heads/master
| 2020-03-21T11:30:14.715865 | 2018-06-24T19:47:13 | 2018-06-24T19:47:13 | 138,509,814 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 27,231 |
java
|
package com.netcracker.project.controllers;
import com.netcracker.project.controllers.validators.CommentValidator;
import com.netcracker.project.controllers.validators.TaskValidator;
import com.netcracker.project.controllers.validators.UserValidator;
import com.netcracker.project.controllers.validators.errorMessage.ErrorMessages;
import com.netcracker.project.model.CommentDAO;
import com.netcracker.project.model.ProjectDAO;
import com.netcracker.project.model.TaskDAO;
import com.netcracker.project.model.UserDAO;
import com.netcracker.project.model.entity.Comment;
import com.netcracker.project.model.entity.Project;
import com.netcracker.project.model.entity.Task.TaskBuilder;
import com.netcracker.project.model.entity.User;
import com.netcracker.project.model.enums.TaskPriority;
import com.netcracker.project.model.enums.TaskStatus;
import com.netcracker.project.model.enums.TaskType;
import com.netcracker.project.model.entity.Task;
import com.netcracker.project.services.impl.DateConverterService;
import java.math.BigInteger;
import java.security.Principal;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.annotation.Secured;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
@RequestMapping("/task")
public class TaskController {
private static Logger logger = Logger
.getLogger(com.netcracker.project.controllers.TaskController.class);
private DateConverterService converter = new DateConverterService();
@Autowired
private TaskDAO taskDAO;
@Autowired
private UserDAO userDAO;
@Autowired
private ProjectDAO projectDAO;
@Autowired
private CommentDAO commentDAO;
@Secured({"ROLE_PM"})
@RequestMapping(value = "selectTaskType", method = RequestMethod.GET)
public String createTaskType() {
return "task/selectTaskType";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "selectTaskType", params = "taskType", method = RequestMethod.GET)
public String createType(@RequestParam("taskType") String taskType, Model model) {
Map<String, String> errorMap = new HashMap<>();
TaskValidator validator = new TaskValidator();
errorMap = validator.validateType(taskType);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/selectTaskType";
}
Collection<String> projects = projectDAO.findAllOpenedProjects();
model.addAttribute("projectNamesList", projects);
return "task/createTask";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "/createTask", method = RequestMethod.POST)
public String createTask(
@RequestParam("name") String name,
@RequestParam("taskType") String taskType,
@RequestParam("startDate") String startDate,
@RequestParam("plannedEndDate") String plannedEndDate,
@RequestParam("priority") String priority,
@RequestParam("description") String description,
@RequestParam("projectNames") String projectName,
@RequestParam("lastName") String lastName,
@RequestParam("firstName") String firstName,
Model model, Principal principal) {
logger.info("begin work with process creation:");
TaskValidator validator = new TaskValidator();
Map<String, String> errorMap = new HashMap<>();
Collection<String> projects = projectDAO.findAllOpenedProjects();
errorMap = validator
.validationCreate(name, taskType, startDate, plannedEndDate, priority,
description, projectName);
if (!errorMap.isEmpty()) {
model.addAttribute("name", name);
model.addAttribute("taskType", taskType);
model.addAttribute("startDate", startDate);
model.addAttribute("plannedEndDate", plannedEndDate);
model.addAttribute("priority", priority);
model.addAttribute("description", description);
model.addAttribute("projectNamesList", projects);
model.addAttribute("errorMap", errorMap);
return "task/createTask";
}
Integer existenceProject = projectDAO
.findProjectByNameIfExist(projectName);
if (existenceProject != 1) {
errorMap.put("PROJECT_EXIST_ERROR", ErrorMessages.PROJECT_EXIST_ERROR);
model.addAttribute("errorMap", errorMap);
return "task/createTask";
}
errorMap = validator.validateLastNameAndFirstName(lastName, firstName);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap",
lastName + " " + firstName + " " + errorMap);
return "task/createTask";
}
Collection<User> users = userDAO
.findUserByLastNameAndFirstName(lastName, firstName);
User user = null;
if (users.isEmpty()) {
errorMap
.put("USER_ERROR", lastName + " " +
firstName + " "
+ ErrorMessages.USER_ERROR);
model.addAttribute("errorMap", errorMap);
return "task/createTask";
}
if (users.size() >= 1) {
Iterator<User> userIterator = users.iterator();
while (userIterator.hasNext()) {
user = userIterator.next();
}
}
Project project = projectDAO.findProjectByName(projectName);
User currentUser = userDAO.findUserByLogin(principal.getName());
Task task = new TaskBuilder()
.taskType(TaskType.valueOf(taskType))
.name(name)
.startDate(converter.convertStringToDateFromJSP(startDate))
.plannedEndDate(converter.convertStringToDateFromJSP(plannedEndDate))
.endDate(converter.convertStringToDateFromJSP(plannedEndDate))
.priority(TaskPriority.valueOf(priority))
.status(TaskStatus.OPENED)
.description(description)
.authorId(currentUser.getUserId())
.userId(user.getUserId())
.reopenCounter(0)
.projectId(project.getProjectId())
.build();
logger.info("createTask request from DB. Task name: " + name);
taskDAO.createTask(task);
return "responseStatus/success";
}
@RequestMapping(value = "/updateTask/{id}", method = RequestMethod.POST)
public String updateTask(
@PathVariable("id") String id,
@RequestParam("name") String name,
@RequestParam("taskType") String type,
@RequestParam("startDate") String startDate,
@RequestParam("endDate") String endDate,
@RequestParam("plannedEndDate") String plannedEndDate,
@RequestParam("priority") String priority,
@RequestParam("status") String status,
@RequestParam("description") String description,
@RequestParam("reopenCounter") Integer reopenCounter,
@RequestParam("lastName") String lastName,
@RequestParam("firstName") String firstName,
@RequestParam("projectNames") String projectName, Model model,
Principal principal) {
logger.info("begin work updating process:");
logger.info("begin work with process creation:");
TaskValidator validator = new TaskValidator();
Map<String, String> errorMap = new HashMap<>();
Collection<String> projects = projectDAO.findAllOpenedProjects();
errorMap = validator.validateInputId(id);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/updateTask";
}
BigInteger validTaskId = new BigInteger(id);
errorMap = validator.validationUpdate(name, type, startDate,
plannedEndDate, priority, status,
description, projectName);
if (!errorMap.isEmpty()) {
model.addAttribute("name", name);
model.addAttribute("taskType", type);
model.addAttribute("startDate", startDate);
model.addAttribute("plannedEndDate", plannedEndDate);
model.addAttribute("priority", priority);
model.addAttribute("status", status);
model.addAttribute("description", description);
model.addAttribute("projectNamesList", projects);
model.addAttribute("errorMap", errorMap);
return "task/updateTask";
}
Integer existenceProject = projectDAO
.findProjectByNameIfExist(projectName);
if (existenceProject != 1) {
errorMap.put("PROJECT_EXIST_ERROR", ErrorMessages.PROJECT_EXIST_ERROR);
model.addAttribute("errorMap", errorMap);
return "task/updateTask";
}
errorMap = validator.validateLastNameAndFirstName(lastName, firstName);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap",
lastName + " " + firstName + " " + errorMap);
return "task/updateTask";
}
Collection<User> users = userDAO
.findUserByLastNameAndFirstName(lastName, firstName);
User user = null;
if (users.isEmpty()) {
errorMap
.put("USER_ERROR", lastName + " " +
firstName + " "
+ ErrorMessages.USER_ERROR);
model.addAttribute("errorMap", errorMap);
return "task/updateTask";
}
if (users.size() >= 1) {
Iterator<User> userIterator = users.iterator();
while (userIterator.hasNext()) {
user = userIterator.next();
}
}
Project updationProject = projectDAO.findProjectByName(projectName);
User currentUser = userDAO.findUserByLogin(principal.getName());
Task updatingTask = new Task.TaskBuilder()
.taskId(validTaskId)
.name(name)
.taskType(TaskType.valueOf(type))
.startDate(converter.convertStringToDateFromJSP(startDate))
.endDate(converter.convertStringToDateFromJSP(endDate))
.plannedEndDate(converter.convertStringToDateFromJSP(plannedEndDate))
.priority(TaskPriority.valueOf(priority))
.status(TaskStatus.valueOf(status))
.description(description)
.reopenCounter(reopenCounter)
.authorId(currentUser.getUserId())
.userId(user.getUserId())
.projectId(updationProject.getProjectId())
.build();
if (TaskStatus.valueOf(status).equals(TaskStatus.REOPENED) || TaskStatus.valueOf(status).equals(TaskStatus.READY_FOR_TESTING)) {
reopenCounter++;
taskDAO.updateReopenCounter(reopenCounter, updatingTask.getTaskId());
}
if (TaskStatus.valueOf(status).equals(TaskStatus.CLOSED)) {
Date date = new Date();
taskDAO.updateEndDate(date, updatingTask.getTaskId());
}
taskDAO.updateTask(updatingTask);
return "responseStatus/success";
}
@RequestMapping(value = "/updateTask/{id}", method = RequestMethod.GET)
public String updateTaskWithGetParams(@PathVariable("id") String id,
Model model, Principal principal) {
logger.info("editTaskWithGetParams method. taskId" + id);
String currentUserLogin = principal.getName();
User currentUser = userDAO.findUserByLogin(currentUserLogin);
BigInteger validId = new BigInteger(id);
Task task = taskDAO.findTaskByTaskId(validId);
User taskUser = userDAO.findUserByUserId(task.getUserId());
Collection<String> projects = projectDAO.findAllOpenedProjects();
model.addAttribute("task", task);
model.addAttribute("taskId", task.getTaskId());
model.addAttribute("name", task.getName());
model.addAttribute("type", task.getTaskType());
model.addAttribute("startDate", task.getStartDate());
model.addAttribute("endDate", task.getEndDate());
model.addAttribute("plannedEndDate", task.getPlannedEndDate());
model.addAttribute("priority", task.getPriority());
model.addAttribute("status", task.getStatus());
model.addAttribute("description", task.getDescription());
model.addAttribute("reopenCounter", task.getReopenCounter());
model.addAttribute("taskUser", taskUser);
model.addAttribute("projectNamesList", projects);
model.addAttribute("curUser", currentUser);
return "task/updateTask";
}
@RequestMapping(value = "/showTask/{taskId}", method = RequestMethod.GET)
public String showTask(@PathVariable("taskId") String taskId,
Model model, Principal principal){
TaskValidator validator = new TaskValidator();
Map<String, String> errorMap = validator.validateInputId(taskId);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/showTask";
}
BigInteger validTaskId = new BigInteger(taskId);
Integer taskExistence = taskDAO.findIfTaskExists(validTaskId);
Map<String, String> existenceError = validator.validateExistence(taskExistence);
if (!existenceError.isEmpty()) {
model.addAttribute("errorMap", existenceError);
return "task/showTask";
}
String currentUserLogin = principal.getName();
User currentUser = userDAO.findUserByLogin(currentUserLogin);
Task task = taskDAO.findTaskByTaskId(validTaskId);
User taskAuthor = userDAO.findUserByUserId(task.getAuthorId());
User taskUser = userDAO.findUserByUserId(task.getUserId());
Project project = projectDAO.findProjectByProjectId(task.getProjectId());
model.addAttribute("task", task);
model.addAttribute("taskId", task.getTaskId());
model.addAttribute("name", task.getName());
model.addAttribute("type", task.getTaskType());
model.addAttribute("startDate", task.getStartDate());
model.addAttribute("endDate", task.getEndDate());
model.addAttribute("plannedEndDate", task.getPlannedEndDate());
model.addAttribute("priority", task.getPriority());
model.addAttribute("status", task.getStatus());
model.addAttribute("description", task.getDescription());
model.addAttribute("reopenCounter", task.getReopenCounter());
model.addAttribute("taskAuthor", taskAuthor);
model.addAttribute("taskUser", taskUser);
model.addAttribute("project", project);
model.addAttribute("curUser", currentUser);
return "task/showTask";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskByPriority", method = RequestMethod.GET)
public String findTaskByPriority() {
return "task/findTaskByPriority";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskPerPeriodAndStatus", method = RequestMethod.GET)
public String findTaskPerPeriodAndStatus() {
return "task/findTaskPerPeriodAndStatus";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskByFirstAndLastName", method = RequestMethod.GET)
public String findTaskByFirstAndLastName() {
return "task/findTaskByFirstAndLastName";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskByProject", method = RequestMethod.GET)
public String findTaskByProject(Model model) {
Collection<String> projects = projectDAO.findAllOpenedProjects();
model.addAttribute("projectNamesList", projects);
return "task/findTaskByProject";
}
@RequestMapping(value = "findOwnTask", method = RequestMethod.GET)
public String findOwnTask() {
return "task/findOwnTask";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskByPriority", params = "priority", method = RequestMethod.GET)
public String showTaskListWithPriority(
@RequestParam(value = "priority") String priority, Model model,
Principal principal) {
Map<String, String> errorMap = new TaskValidator()
.validationFindTaskByPriority(priority);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/findTaskByPriority";
}
String loginUser = principal.getName();
User user = userDAO.findUserByLogin(loginUser);
Collection<Task> tasks = taskDAO
.findTaskByUserIdAndPriority(user.getUserId(),
TaskPriority.valueOf(priority).getId());
Task task = null;
if (tasks.size() >= 1) {
Iterator<Task> taskIterator = tasks.iterator();
while (taskIterator.hasNext()) {
task = taskIterator.next();
}
}
if (tasks.isEmpty()){
Map<String, String> error = new TaskValidator().validationEntityTask(task);
if (!error.isEmpty()) {
model.addAttribute("errorMap", error);
return "task/viewTask";
}
}
model.addAttribute("taskList", tasks);
return "task/viewTask";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskPerPeriodAndStatus", params = {"status", "startDate",
"endDate"}, method = RequestMethod.GET)
public String findTaskListWithPeriods(@RequestParam("status") String status,
@RequestParam("startDate") String startDate,
@RequestParam("endDate") String endDate, Model model,
Principal principal) {
Map<String, String> errorMap = new HashMap<>();
TaskValidator validator = new TaskValidator();
errorMap = validator.validationFindTaskByStatus(status);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/findTaskPerPeriodAndStatus";
}
errorMap = validator.validateBetweenDates(startDate, endDate);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/findTaskPerPeriodAndStatus";
}
String loginUser = principal.getName();
User user = userDAO.findUserByLogin(loginUser);
Collection<Task> tasksPerPeriod = taskDAO
.findTaskByUserAndStatusPerPeriod(user.getUserId(),
TaskStatus.valueOf(status).getId(),
converter.convertStringToDateFromJSP(startDate),
converter.convertStringToDateFromJSP(endDate));
Task task = null;
if (tasksPerPeriod.size() >= 1) {
Iterator<Task> taskIterator = tasksPerPeriod.iterator();
while (taskIterator.hasNext()) {
task = taskIterator.next();
}
}
if (tasksPerPeriod.isEmpty()){
Map<String, String> error = new TaskValidator().validationEntityTask(task);
if (!error.isEmpty()) {
model.addAttribute("errorMap", error);
return "task/viewTask";
}
}
model.addAttribute("taskList", tasksPerPeriod);
return "task/viewTask";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskByFirstAndLastName", params = {"lastName", "firstName", "status"}, method = RequestMethod.GET)
public String showTaskListWithUsers(
@RequestParam("lastName") String lastName,
@RequestParam("firstName") String firstName,
@RequestParam("status") String status, Model model) {
Map<String, String> errorMap = new TaskValidator().validateLastNameAndFirstName(lastName, firstName);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/findTaskByFirstAndLastName";
}
Collection<User> users = userDAO.findUserByLastNameAndFirstName(lastName, firstName);
if (users.isEmpty()) {
errorMap.put("USER_ERROR", lastName + " " +
firstName + " "
+ ErrorMessages.USER_ERROR);
model.addAttribute("errorMap", errorMap);
return "task/findTaskByFirstAndLastName";
}
User user = null;
if (users.size() >= 1) {
Iterator<User> userIterator = users.iterator();
while (userIterator.hasNext()) {
user = userIterator.next();
}
}
Collection<Task> tasks = taskDAO.findTaskByUserIdAndStatus(user.getUserId(), TaskStatus.valueOf(status).getId());
errorMap = new TaskValidator()
.validationFindTaskByStatus(status);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/viewTask";
}
Task task = null;
if (tasks.size() >= 1) {
Iterator<Task> taskIterator = tasks.iterator();
while (taskIterator.hasNext()) {
task = taskIterator.next();
}
}
if (tasks.isEmpty()){
Map<String, String> existenceError = new TaskValidator().validationEntityTask(task);
if (!existenceError.isEmpty()) {
model.addAttribute("errorMap", existenceError);
return "task/viewTask";
}
}
model.addAttribute("taskList", tasks);
return "task/viewTask";
}
@RequestMapping(value = "findOwnTask", params = "status", method = RequestMethod.GET)
public String showTaskOwnTask(
@RequestParam(value = "status") String status, Model model,
Principal principal) {
Map<String, String> errorMap = new TaskValidator().validationFindTaskByStatus(status);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/viewTask";
}
String loginUser = principal.getName();
User user = userDAO.findUserByLogin(loginUser);
Collection<Task> tasks = taskDAO.findTaskByUserIdAndStatus(user.getUserId(),
TaskStatus.valueOf(status).getId());
Task task = null;
if (tasks.size() >= 1) {
Iterator<Task> taskIterator = tasks.iterator();
while (taskIterator.hasNext()) {
task = taskIterator.next();
}
}
if (tasks.isEmpty()){
Map<String, String> error = new TaskValidator().validationEntityTask(task);
if (!error.isEmpty()) {
model.addAttribute("errorMap", error);
return "task/viewTask";
}
}
model.addAttribute("taskList", tasks);
return "task/viewTask";
}
@Secured({"ROLE_PM"})
@RequestMapping(value = "findTaskByProject", params = "project", method = RequestMethod.GET)
public String showTaskListWithProjects(@RequestParam("project") String projectName, Model model) {
Collection<String> projects = projectDAO.findAllOpenedProjects();
Map<String, String> errorMap = new TaskValidator().validationFindTaskByProject(projectName);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
model.addAttribute("projectNamesList", projects);
return "task/findTaskByProject";
}
Integer existenceProject = projectDAO.findProjectByNameIfExist(projectName);
if (existenceProject != 1) {
errorMap.put("PROJECT_EXIST_ERROR", ErrorMessages.PROJECT_EXIST_ERROR);
model.addAttribute("errorMap", errorMap);
return "task/findTaskByProject";
}
Project project = projectDAO.findProjectByName(projectName);
Collection<Task> tasks = taskDAO.findTaskByProjectId(project.getProjectId());
Task task = null;
if (tasks.size() >= 1) {
Iterator<Task> taskIterator = tasks.iterator();
while (taskIterator.hasNext()) {
task = taskIterator.next();
}
}
if (tasks.isEmpty()){
Map<String, String> existenceError = new TaskValidator().validationEntityTask(task);
if (!existenceError.isEmpty()) {
model.addAttribute("errorMap", existenceError);
return "task/viewTask";
}
}
model.addAttribute("taskList", tasks);
return "task/viewTask";
}
@RequestMapping(value = "/createComment/taskId/{taskId}/userId/{userId}/creationDate/{creationDate}",
method = RequestMethod.POST)
public String createComment(
@RequestParam("bodyComment") String bodyComment,
@PathVariable("creationDate") String creationDate,
@PathVariable("taskId") String taskId,
@PathVariable("userId") String userId,
Model model, Principal principal) {
logger.info("begin work with creation comment : ");
CommentValidator validator = new CommentValidator();
Map<String, String> errorMap = new HashMap<>();
errorMap = validator.validationCreate(bodyComment);
if (!errorMap.isEmpty()) {
model.addAttribute("bodyComment", bodyComment);
model.addAttribute("errorMap", errorMap);
return "task/createComment";
}
TaskValidator taskValidator = new TaskValidator();
errorMap = taskValidator.validateInputId(taskId);
if (!errorMap.isEmpty()){
model.addAttribute("errorMap", errorMap);
}
UserValidator userValidator = new UserValidator();
errorMap = userValidator.validateInputId(userId);
BigInteger validTaskId = new BigInteger(taskId);
Task tasks = taskDAO.findTaskByTaskId(validTaskId);
String currentUserLogin = principal.getName();
User currentUser = userDAO.findUserByLogin(currentUserLogin);
if (!errorMap.isEmpty()){
model.addAttribute("errorMap", errorMap);
}
if (!errorMap.isEmpty()){
model.addAttribute("creationDate", creationDate);
model.addAttribute("errorMap", errorMap);
}
Comment comment = new Comment.CommentBuilder()
.bodyComment(bodyComment)
.creationDate(converter.convertStringToDateFromJSP(creationDate))
.userId(currentUser.getUserId())
.taskId(tasks.getTaskId())
.lastName(currentUser.getLastName())
.firstName(currentUser.getFirstName())
.build();
commentDAO.createComment(comment);
commentDAO.updateCreationDate(comment.getCreationDate(), comment.getCommentId());
return "responseStatus/success";
}
@RequestMapping(value = "/createComment/{taskId}", method = RequestMethod.GET)
public String createCommentGet(@PathVariable(value = "taskId") String taskId,
Model model, Principal principal) {
logger.info("createComment with get params.: ");
Map<String, String> errorMap = new HashMap<>();
TaskValidator validator = new TaskValidator();
errorMap = validator.validateInputId(taskId);
if (!errorMap.isEmpty()){
model.addAttribute("errorMap", errorMap);
}
if (!errorMap.isEmpty()){
model.addAttribute("errorMap", errorMap);
}
String currentUserLogin = principal.getName();
User currentUser = userDAO.findUserByLogin(currentUserLogin);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = new Date();
model.addAttribute("errorMap", errorMap);
model.addAttribute("userId", currentUser.getUserId());
model.addAttribute("creationDate", sdf.format(date));
return "task/createComment";
}
@RequestMapping(value = "/showAllComments/{taskId}", method = RequestMethod.GET)
public String showAllComments(@PathVariable("taskId") String taskId, Model model){
CommentValidator commentValidator = new CommentValidator();
TaskValidator taskValidator = new TaskValidator();
Map<String, String> errorMap = new HashMap<>();
errorMap = taskValidator.validateInputId(taskId);
if (!errorMap.isEmpty()) {
model.addAttribute("errorMap", errorMap);
return "task/showAllComments";
}
BigInteger validTaskId = new BigInteger(taskId);
Task task = taskDAO.findTaskByTaskId(validTaskId);
List<Comment> comments = commentDAO.getCommentsForTask(validTaskId);
Comment comment = null;
if (comments.size() >= 1) {
Iterator<Comment> commentIterator = comments.iterator();
while (commentIterator.hasNext()) {
comment = commentIterator.next();
}
}
if (comments.isEmpty()){
Map<String, String> existenceError = new CommentValidator().validationEntityComment(comment);
if (!existenceError.isEmpty()) {
model.addAttribute("errorMap", existenceError);
return "task/showAllComments";
}
}
model.addAttribute("task", task);
model.addAttribute("comments", comments);
return "task/showAllComments";
}
}
|
[
"[email protected]"
] | |
3c901cc94d75a251aef8643c01a008c0158aa72e
|
dcdda45fda3853a0d6b798d37d5443193a19e6fa
|
/src/main/java/jdbc/monitor/Test.java
|
99a497b378f7103cc3a90f24182bd7686da32064
|
[] |
no_license
|
devarchi33/devarchi33-jdbc-mornitoring
|
70d50634784bfe3eb8406584e490f16f3e990a06
|
859303d2b9759268453d8e1762706a608174120b
|
refs/heads/master
| 2020-12-03T05:13:28.346111 | 2016-04-01T10:44:42 | 2016-04-01T10:44:42 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 237 |
java
|
package jdbc.monitor;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
MonitoringManager manager = MonitoringManager.getInstance();
manager.init();
}
}
|
[
"[email protected]"
] | |
ae287e388a519cc1e6b302d2493f7b14c511b4f7
|
a3ac67a8960ef0d0300aeea7cbe87951f2e37cf2
|
/Xdownloader/src/androidTest/java/com/android/downloadx/ExampleInstrumentedTest.java
|
4a9b8a02b229353a99d3aa684c4a40d26f5bc608
|
[] |
no_license
|
asadd00/XDownloader
|
3cb21ef9ff5ca11834ed2c4bcdd7d4f31f557879
|
6f9882ded3242ad1526f77212674914b122529c8
|
refs/heads/master
| 2022-03-22T12:17:00.723097 | 2019-12-04T12:30:37 | 2019-12-04T12:30:37 | 208,955,765 | 1 | 1 | null | null | null | null |
UTF-8
|
Java
| false | false | 743 |
java
|
package com.android.downloadx;
import android.content.Context;
import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getTargetContext();
assertEquals("com.android.downloadx.test", appContext.getPackageName());
}
}
|
[
"[email protected]"
] | |
90f0863dbe019dbb031f3c15e4b53d0205c348bd
|
edb77dddffea182ddfedbb15e38f1b242bfbe4ac
|
/src/main/java/com/zhych/sell/controller/PayController.java
|
0136a10dd9fad14b121e6679d85e4c69b34e225c
|
[] |
no_license
|
zhych1005/sell
|
6cd3f548393f00c0f40804f02d797f3e36f1d98c
|
d0d3ca3d77ededdf5c14c3cd989a8d509529e633
|
refs/heads/master
| 2021-03-21T17:00:53.618317 | 2020-03-14T16:39:41 | 2020-03-14T16:39:41 | 247,313,936 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,005 |
java
|
package com.zhych.sell.controller;
import com.zhych.sell.dto.OrderDTO;
import com.zhych.sell.enums.ResultEnum;
import com.zhych.sell.exception.SellException;
import com.zhych.sell.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
@RequestMapping("/pay")
public class PayController {
@Autowired
private OrderService orderService;
@GetMapping("/create")
public void create(@RequestParam("orderId") String orderId,
@RequestParam("returnUrl") String returnUrl) {
//1.查询订单
OrderDTO orderDTO = orderService.findOne(orderId);
if (orderDTO == null) {
throw new SellException(ResultEnum.ORDER_NOT_EXIST);
}
//发起支付
}
}
|
[
"[email protected]"
] | |
a1ce120283e2ffa4873dd073656c2ad009e5b737
|
81827fa1d8bcd437e0f4d43d9d956c9902128c18
|
/src/main/java/com/example/listingapp_rest/security/security/CurrentUser.java
|
4387fd6f76b8a935385b7b017bd553abcd708f16
|
[] |
no_license
|
Arman2000-00/listing-app_rest
|
d897000c4c8df0b8f569f64f4438d9a41e08e6af
|
ed386d10743a7383112f7d5c0eb4434f4c13c571
|
refs/heads/master
| 2023-08-24T04:08:12.484797 | 2021-10-02T22:53:30 | 2021-10-02T22:53:30 | 408,582,403 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 524 |
java
|
package com.example.listingapp_rest.security.security;
import com.example.listingapp_rest.model.User;
import org.springframework.security.core.authority.AuthorityUtils;
public class CurrentUser extends org.springframework.security.core.userdetails.User {
private User user;
public CurrentUser(User user) {
super(user.getEmail(), user.getPassword(), AuthorityUtils.createAuthorityList(user.getUserRole().name()));
this.user = user;
}
public User getUser() {
return user;
}
}
|
[
"[email protected]"
] | |
8fcf53010fc31955944adf259f4a1ba5cd6dc131
|
4526e17330e4fb6fca3864aa9befbb4ba6fcccee
|
/PropertyManagement06/src/main/java/com/neusoft/wuyemis/test/AreaTest.java
|
b31591ad8396fb9fa61efb8c948ac5376dcf9adc
|
[] |
no_license
|
Liu-yongchao/Ss-manage
|
346e7cb6f02cd7ee1162c54317110624496dcea6
|
12f194ca40ac749ee59f51dfaed59d83f12b1228
|
refs/heads/master
| 2022-06-26T10:04:22.838144 | 2019-08-21T03:23:09 | 2019-08-21T03:23:09 | 133,588,400 | 0 | 0 | null | 2022-06-21T04:13:28 | 2018-05-16T00:33:02 |
JavaScript
|
UTF-8
|
Java
| false | false | 339 |
java
|
package com.neusoft.wuyemis.test;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/user")
public class AreaTest {
@RequestMapping("/add")
public String add() throws Exception{
return "增加成功";
}
}
|
[
"[email protected]"
] | |
65740c2cf5a736fbb99f39d6953526df34e5c909
|
b3121f154fb8d5b1af0d4c043db25535f7642a9d
|
/recommend-system/src/main/java/com/elikv/recommendsystem/dao/RankShopDao.java
|
61cbcbe5dca4bfe91bfff9d1aee38b93af14c7d9
|
[] |
no_license
|
elikv/recommend-system
|
a8ed0de03d82cadffbbb84969a04b2023fd1eed4
|
e3b9ea400f74f8302ce630742a9e06f3887228fa
|
refs/heads/master
| 2021-04-27T20:01:09.346788 | 2018-03-07T14:28:43 | 2018-03-07T14:28:43 | 122,368,987 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,297 |
java
|
package com.elikv.recommendsystem.dao;
import com.elikv.recommendsystem.model.RankShopInfo;
import com.elikv.recommendsystem.model.ShopIdRankTimeScoreEntity;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
/**
* @author elikv
* Date: 17-6-23
* Time: 下午4:27
*/
@Repository
public interface RankShopDao {
//添加大众点评网的数据到数据库
public int addList(List<RankShopInfo> dianPingInfo);
public List<RankShopInfo>findByShopId(int shopId);
public List<RankShopInfo>findByShopIdAndRankTime(Map<String, Object> map);
public List<RankShopInfo>findByShopIdAndRankType(Map<String, Object> map);
/**
* 显示所有id
*/
public List<String>findShopIdAll();
public void deletefromId(String id);
/**
* 从t_rank_shop中寻找shopId-RankTime-Score关系
* @return
*/
public List<ShopIdRankTimeScoreEntity> findShopIdRankTimeScore();
/**
* 显示数据 牛顿冷却定律排序
*/
public List<RankShopInfo>findNewtonCooling(Map<String, Object> map);
/**
* 根据指定id 拿到数据
* @param map
* @return
*/
public List<RankShopInfo>findLabelShop(Map<String, Object> map);
}
|
[
"[email protected]"
] | |
77f2894188016be0f30b687afee06cc62288f146
|
a72fb25288be9ec8b2dd37bdf29f869f01d0ab25
|
/src/leetcode/again/Again19.java
|
60dbcf447911798fe088e7a8a48c1acb51364217
|
[] |
no_license
|
xuchen-pbw/Code
|
0944bf76ed84ac0c00f8c3594d2fae8c8efacd1c
|
0cddee94a21f71e12e54876796ddd7582f086347
|
refs/heads/master
| 2022-07-12T04:50:26.647437 | 2022-06-02T13:48:55 | 2022-06-02T13:48:55 | 216,830,474 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 884 |
java
|
package leetcode.again;
/**
* @author xuchen.pbw
* @description
* @date 2022/4/18
*
* 题目：删除链表的倒数第n个节点
* 哨兵节点，快慢指针。快指针先走顺向n，剩余的路就是正向位数
*/
public class Again19 {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode tmp = new ListNode(0);
tmp.next = head;
ListNode p1 = tmp;
ListNode p2 = tmp;
for(int i = 0;i < n;i++){
p1 = p1.next;
}
while(p1.next!=null){
p1 = p1.next;
p2 = p2.next;
}
p2.next = p2.next.next;
return tmp.next;
}
public class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
}
|
[
"[email protected]"
] | |
52459acd7f7ecf45e20ddc70209ab5ebad88ba95
|
c885ef92397be9d54b87741f01557f61d3f794f3
|
/tests-without-trycatch/JacksonCore-18/com.fasterxml.jackson.core.json.UTF8JsonGenerator/BBC-F0-opt-70/27/com/fasterxml/jackson/core/json/UTF8JsonGenerator_ESTest.java
|
9181a2bc9e0433b55ef2a4534906b75ea25b3b4e
|
[
"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,551,993 |
java
|
/*
* This file was automatically generated by EvoSuite
* Sat Oct 23 14:20:12 GMT 2021
*/
package com.fasterxml.jackson.core.json;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.evosuite.shaded.org.mockito.Mockito.*;
import static org.evosuite.runtime.EvoAssertions.*;
import com.fasterxml.jackson.core.Base64Variant;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.core.SerializableString;
import com.fasterxml.jackson.core.Version;
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.io.IOContext;
import com.fasterxml.jackson.core.io.SerializedString;
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.sym.ByteQuadsCanonicalizer;
import com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer;
import com.fasterxml.jackson.core.util.BufferRecycler;
import com.fasterxml.jackson.core.util.ByteArrayBuilder;
import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
import com.fasterxml.jackson.core.util.TextBuffer;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintStream;
import java.io.PushbackInputStream;
import java.io.SequenceInputStream;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.util.Enumeration;
import java.util.Locale;
import org.evosuite.runtime.EvoRunner;
import org.evosuite.runtime.EvoRunnerParameters;
import org.evosuite.runtime.Random;
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.testdata.EvoSuiteFile;
import org.evosuite.runtime.testdata.FileSystemHandling;
import org.junit.runner.RunWith;
@RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true)
public class UTF8JsonGenerator_ESTest extends UTF8JsonGenerator_ESTest_scaffolding {
@Test(timeout = 4000)
public void test000() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("EN6M ");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals(69, int0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 63, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(63, readerBasedJsonParser0.getFeatureMask());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_COMMENTS;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.disable(jsonParser_Feature0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(61, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(61, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser1);
SerializedString serializedString0 = new SerializedString("^>GXAs[`]Qsy(S");
assertEquals(15, serializedString0.charLength());
assertEquals("^>GXAs[`]Qsy(S", serializedString0.toString());
assertEquals("^>GXAs[`]Qsy(S", serializedString0.getValue());
assertNotNull(serializedString0);
char[] charArray0 = serializedString0.asQuotedChars();
assertEquals(15, serializedString0.charLength());
assertEquals("^>GXAs[`]Qsy(S", serializedString0.toString());
assertEquals("^>GXAs[`]Qsy(S", serializedString0.getValue());
assertEquals(15, charArray0.length);
assertNotNull(charArray0);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(fileDescriptor0);
assertNotNull(mockFileOutputStream0);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)91;
byteArray0[1] = (byte)107;
byteArray0[2] = (byte) (-83);
byteArray0[3] = (byte)100;
byteArray0[4] = (byte) (-108);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-2630), (ObjectCodec) null, mockFileOutputStream0, byteArray0, 762, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(762, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-2630), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(fileDescriptor0.valid());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91, (byte)107, (byte) (-83), (byte)100, (byte) (-108)}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
byte[] byteArray1 = new byte[0];
assertFalse(byteArray1.equals((Object)byteArray0));
// try {
uTF8JsonGenerator0.writeBinary((Base64Variant) null, byteArray1, 3, 65535);
// 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 test001() throws Throwable {
MockFile mockFile0 = new MockFile(" in a commJnt");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream(mockFile0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
byte[] byteArray0 = new byte[15];
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, sequenceInputStream0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
char[] charArray0 = iOContext1.allocTokenBuffer(0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(charArray0);
SequenceInputStream sequenceInputStream1 = new SequenceInputStream(sequenceInputStream0, sequenceInputStream0);
assertFalse(sequenceInputStream1.equals((Object)sequenceInputStream0));
assertNotNull(sequenceInputStream1);
IOContext iOContext2 = new IOContext(bufferRecycler0, sequenceInputStream1, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(sequenceInputStream0.equals((Object)sequenceInputStream1));
assertFalse(sequenceInputStream1.equals((Object)sequenceInputStream0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 460, (ObjectCodec) null, mockPrintStream0, byteArray0, 2408, true);
assertEquals(" in a commJnt", mockFile0.toString());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.getFreeSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canWrite());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(" in a commJnt", mockFile0.getName());
assertTrue(mockFile0.canRead());
assertFalse(mockFile0.isAbsolute());
assertTrue(mockFile0.isFile());
assertEquals(0L, mockFile0.length());
assertTrue(mockFile0.exists());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(2408, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(460, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(sequenceInputStream0.equals((Object)sequenceInputStream1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(15, byteArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeString(charArray0, 2, 8);
assertEquals(" in a commJnt", mockFile0.toString());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.getFreeSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canWrite());
assertEquals(52L, mockFile0.length());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(" in a commJnt", mockFile0.getName());
assertTrue(mockFile0.canRead());
assertFalse(mockFile0.isAbsolute());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.exists());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(460, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(sequenceInputStream0.equals((Object)sequenceInputStream1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(15, byteArray0.length);
assertEquals(4000, charArray0.length);
assertNotSame(sequenceInputStream0, sequenceInputStream1);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0._verifyValueWrite("");
assertEquals(" in a commJnt", mockFile0.toString());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.getFreeSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canWrite());
assertEquals(52L, mockFile0.length());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(" in a commJnt", mockFile0.getName());
assertTrue(mockFile0.canRead());
assertFalse(mockFile0.isAbsolute());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.exists());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(460, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(sequenceInputStream0.equals((Object)sequenceInputStream1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(15, byteArray0.length);
assertNotSame(sequenceInputStream0, sequenceInputStream1);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test002() throws Throwable {
Random.setNextRandom((-3));
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("}");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(readerBasedJsonParser0, tokenFilter0, false, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(2, filteringParserDelegate0.getFeatureMask());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(filteringParserDelegate0);
ObjectCodec objectCodec0 = filteringParserDelegate0.getCodec();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(2, filteringParserDelegate0.getFeatureMask());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(objectCodec0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte)16;
byteArray0[1] = (byte)42;
byteArray0[2] = (byte)13;
byteArray0[3] = (byte)32;
byteArray0[4] = (byte) (-31);
byteArray0[5] = (byte) (-28);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 128, (ObjectCodec) null, byteArrayOutputStream0, byteArray0, (byte) (-31), false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-31), uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(128, uTF8JsonGenerator0.getFeatureMask());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte)16, (byte)42, (byte)13, (byte)32, (byte) (-31), (byte) (-28)}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
int int0 = uTF8JsonGenerator0.getOutputBuffered();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-31), uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(128, uTF8JsonGenerator0.getFeatureMask());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte)16, (byte)42, (byte)13, (byte)32, (byte) (-31), (byte) (-28)}, byteArray0);
assertEquals((-31), int0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test003() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
File file0 = MockFile.createTempFile(" in a comment", " in a comment");
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(file0);
assertNotNull(mockFileInputStream0);
BufferedInputStream bufferedInputStream0 = new BufferedInputStream(mockFileInputStream0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0, mockFileInputStream0.available());
assertNotNull(bufferedInputStream0);
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(bufferedInputStream0, bufferedInputStream0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0, mockFileInputStream0.available());
assertNotNull(sequenceInputStream0);
IOContext iOContext1 = new IOContext(bufferRecycler0, sequenceInputStream0, false);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0, mockFileInputStream0.available());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 3, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0, mockFileInputStream0.available());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(3, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator0.writeString("");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)34, (byte)34, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator1._flushBuffer();
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(" in a comment0 in a comment", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0, mockFileInputStream0.available());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(3, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)34, (byte)34, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test004() throws Throwable {
MockFile mockFile0 = new MockFile("-]43,MgP{");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream("-]43,MgP{");
assertNotNull(mockPrintStream0);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, true);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-]43,MgP{", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertNotNull(bigInteger0);
int int0 = 108;
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(fileDescriptor0);
assertNotNull(mockFileOutputStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)57;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 108, (ObjectCodec) null, mockFileOutputStream0, byteArray0, 108, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(fileDescriptor0.valid());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(108, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(108, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)57}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// try {
uTF8JsonGenerator0.writeNumber(bigInteger0);
// 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 test005() throws Throwable {
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-415), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-415), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.flush();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-415), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.flush();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-415), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test006() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(" in a comment");
assertNotNull(mockPrintStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.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);
assertNotNull(iOContext0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
byte[] byteArray0 = new byte[5];
byteArray0[1] = (byte)83;
byte[] byteArray1 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(2000, byteArray1.length);
assertNotSame(byteArray1, byteArray0);
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);
assertNotNull(byteArray1);
byteArray0[3] = (byte)0;
byteArray0[3] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, mockPrintStream0, byteArray0, 2, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)83, (byte)0, (byte)83, (byte)0}, byteArray0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeRaw("2.7.7-SNAPSHOT");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)84, (byte)80, (byte)83, (byte)72, (byte)79}, byteArray0);
assertNotSame(byteArray0, byteArray1);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString((String) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)110, (byte)117, (byte)108, (byte)108, (byte)79}, byteArray0);
assertNotSame(byteArray0, byteArray1);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName(" in a comment");
// 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 test007() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", " in a comment");
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(file0);
assertNotNull(mockFileInputStream0);
BufferedInputStream bufferedInputStream0 = new BufferedInputStream(mockFileInputStream0);
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, mockFileInputStream0.available());
assertNotNull(bufferedInputStream0);
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(bufferedInputStream0, bufferedInputStream0);
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, mockFileInputStream0.available());
assertNotNull(sequenceInputStream0);
IOContext iOContext1 = new IOContext(bufferRecycler0, sequenceInputStream0, false);
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-5050), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-5050), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(readerBasedJsonParser0, tokenFilter0, true, false);
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-5050), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertEquals((-5050), filteringParserDelegate0.getFeatureMask());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(filteringParserDelegate0);
ObjectCodec objectCodec0 = filteringParserDelegate0.getCodec();
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-5050), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertEquals((-5050), filteringParserDelegate0.getFeatureMask());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(objectCodec0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 51311, (ObjectCodec) null, mockPrintStream0);
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(51311, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString("D-(N");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(9, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)34, (byte)68, (byte)45, (byte)40, (byte)78, (byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeFieldName("-\rJ;87y;o");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals(18L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)59, (byte)111, (byte)92, (byte)114, (byte)74, (byte)59, (byte)56, (byte)55, (byte)121}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// try {
uTF8JsonGenerator0.writeEndArray();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an ARRAY but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test008() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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);
assertNotNull(iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler1);
Object object0 = new Object();
assertNotNull(object0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("/o=,L?i", true);
assertNotNull(mockFileOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 9, (ObjectCodec) null, mockFileOutputStream0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, 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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
Object object1 = uTF8JsonGenerator0.getOutputTarget();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(mockFileOutputStream0, object1);
assertSame(object1, mockFileOutputStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(object1);
IOContext iOContext1 = new IOContext(bufferRecycler1, object1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
Object object2 = uTF8JsonGenerator0.getOutputTarget();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(mockFileOutputStream0, object2);
assertSame(mockFileOutputStream0, object1);
assertSame(object2, object1);
assertSame(object2, mockFileOutputStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(object2);
IOContext iOContext2 = new IOContext(bufferRecycler1, object2, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext2);
char[] charArray0 = iOContext2.allocTokenBuffer(3);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(mockFileOutputStream0, object2);
assertSame(mockFileOutputStream0, object1);
assertSame(object2, object1);
assertSame(object2, mockFileOutputStream0);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(charArray0);
IOContext iOContext3 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext3);
byte[] byteArray0 = new byte[0];
int[] intArray0 = new int[9];
intArray0[0] = 1;
intArray0[1] = 1;
intArray0[2] = 0;
intArray0[3] = 1;
intArray0[4] = 845;
intArray0[5] = 56320;
intArray0[6] = 55296;
intArray0[7] = 0;
intArray0[8] = 125;
uTF8JsonGenerator0._outputEscapes = intArray0;
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockFileOutputStream0, byteArray0, 97, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(97, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator0.writeString(charArray0, 0, 10);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(22, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(mockFileOutputStream0, object2);
assertSame(mockFileOutputStream0, object1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(object2, object1);
assertSame(object2, mockFileOutputStream0);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator1._verifyValueWrite("acfj 4'yHl@5fIOza");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(9, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(22, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(97, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(mockFileOutputStream0, object2);
assertSame(mockFileOutputStream0, object1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(object1, object2);
assertSame(object1, mockFileOutputStream0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
}
@Test(timeout = 4000)
public void test009() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile("AQ`!}<4h-Y1*4Kx9(3", (String) null);
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("AQ`!}<4h-Y1*4Kx9(30.tmp", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/AQ`!}<4h-Y1*4Kx9(30.tmp", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertNotNull(file0);
byte[] byteArray0 = new byte[1];
SerializedString serializedString0 = new SerializedString("AQ`!}<4h-Y1*4Kx9(3");
assertEquals(18, serializedString0.charLength());
assertEquals("AQ`!}<4h-Y1*4Kx9(3", serializedString0.getValue());
assertEquals("AQ`!}<4h-Y1*4Kx9(3", serializedString0.toString());
assertNotNull(serializedString0);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(fileDescriptor0);
assertNotNull(mockFileOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockFileOutputStream0, byteArray0, 1120, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(fileDescriptor0.valid());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1120, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
// try {
uTF8JsonGenerator0.writeRaw("AQ`!}<4h-Y1*4Kx9(3");
// 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 test010() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "-]43,MgP{");
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0-]43,MgP{", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/-]43,MgP{0-]43,MgP{", file0.toString());
assertTrue(file0.canWrite());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[23];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, true);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-]43,MgP{", true);
assertTrue(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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0-]43,MgP{", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/-]43,MgP{0-]43,MgP{", file0.toString());
assertTrue(file0.canWrite());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber((long) 1);
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0-]43,MgP{", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/-]43,MgP{0-]43,MgP{", file0.toString());
assertTrue(file0.canWrite());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(23, byteArrayInputStream0.available());
assertEquals(23, byteArray0.length);
assertNotNull(byteArrayInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 3);
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0-]43,MgP{", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/-]43,MgP{0-]43,MgP{", file0.toString());
assertTrue(file0.canWrite());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(20, byteArrayInputStream0.available());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertEquals(3, int0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
byte[] byteArray1 = new byte[2];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)79;
byteArray1[1] = (byte)5;
// Undeclared exception!
// try {
uTF8JsonGenerator0._writeBinary((Base64Variant) null, byteArrayInputStream0, byteArray1, 3732);
// 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 test011() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/experiment");
boolean boolean0 = FileSystemHandling.shouldThrowIOException(evoSuiteFile0);
assertTrue(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
MockFile mockFile0 = new MockFile(", expecting field name");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream(mockFile0);
assertNotNull(mockPrintStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertEquals(0L, mockFile0.getTotalSpace());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.exists());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertFalse(mockFile0.isDirectory());
assertEquals(", expecting field name", mockFile0.getName());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray0);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertEquals(0L, mockFile0.getTotalSpace());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.exists());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertFalse(mockFile0.isDirectory());
assertEquals(", expecting field name", mockFile0.getName());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[5];
charArray0[0] = '\u0082';
charArray0[1] = '\u0082';
charArray0[2] = '\u0082';
charArray0[3] = '\u0082';
charArray0[4] = '\u0082';
uTF8JsonGenerator0.writeString(charArray0, 2, 1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertEquals(0L, mockFile0.getTotalSpace());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.exists());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertFalse(mockFile0.isDirectory());
assertEquals(", expecting field name", mockFile0.getName());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'\u0082', '\u0082', '\u0082', '\u0082', '\u0082'}, charArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertEquals(0L, mockFile0.getTotalSpace());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.exists());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertFalse(mockFile0.isDirectory());
assertEquals(", expecting field name", mockFile0.getName());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRaw(charArray0, 2, 2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertEquals(0L, mockFile0.getTotalSpace());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.exists());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canExecute());
assertFalse(mockFile0.isDirectory());
assertEquals(", expecting field name", mockFile0.getName());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'\u0082', '\u0082', '\u0082', '\u0082', '\u0082'}, charArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test012() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "_0|a*[2Xm%WsA]N?y");
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[23];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-]43,MgP{", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, false);
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertNotNull(bigInteger0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(23, byteArray0.length);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber(2);
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber((long) 2);
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(3L, file0.length());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber(0L);
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(5L, file0.length());
assertTrue(file0.canExecute());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(23, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test013() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0._writePPFieldName(serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeNumber((short)4);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(9, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// try {
uTF8JsonGenerator1.writeStartArray();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not start an array, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test014() throws Throwable {
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 1, 5);
assertEquals(5, byteArrayInputStream0.available());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(byteArrayInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, byteArrayInputStream0, true);
assertEquals(5, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-2), (ObjectCodec) null, mockPrintStream0, byteArray0, 4, false);
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(5, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-2), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeNull();
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(5, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-2), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)110, (byte)117, (byte)108, (byte)108, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeFieldName("ZrgX%Zb](!~");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertEquals(20L, file0.length());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(5, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-2), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)33, (byte)126, (byte)34, (byte)103, (byte)88, (byte)37, (byte)90, (byte)98, (byte)93, (byte)40}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// try {
uTF8JsonGenerator0.writeEndObject();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an object but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test015() throws Throwable {
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0, 1, 5);
assertEquals(5, byteArrayInputStream0.available());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(byteArrayInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, byteArrayInputStream0, true);
assertEquals(5, byteArrayInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-2), (ObjectCodec) null, mockPrintStream0, byteArray0, 4, false);
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(5, byteArrayInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-2), uTF8JsonGenerator0.getFeatureMask());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeFieldName("ZrgX%Zb](!~");
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(10L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(5, byteArrayInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-2), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)37, (byte)90, (byte)98, (byte)93, (byte)40, (byte)33, (byte)126, (byte)34, (byte)103, (byte)88}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// try {
uTF8JsonGenerator0.writeEndObject();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an object but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test016() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "T");
assertEquals(" in a comment0T", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(fileDescriptor0);
assertNotNull(mockFileInputStream0);
byte[] byteArray0 = new byte[15];
byteArray0[1] = (byte)0;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(15, byteArrayInputStream0.available());
assertEquals(15, byteArray0.length);
assertNotNull(byteArrayInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, byteArrayInputStream0, true);
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(15, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2414, (ObjectCodec) null, mockPrintStream0, byteArray0, 2, true);
assertEquals(" in a comment0T", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(15, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(15, byteArray0.length);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertEquals(" in a comment0T", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(15, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber((int) (byte)34);
assertEquals(5L, file0.length());
assertEquals(" in a comment0T", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(15, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.AUTO_CLOSE_TARGET;
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.disable(jsonGenerator_Feature0);
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(2414, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(5L, file0.length());
assertEquals(" in a comment0T", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(15, byteArray0.length);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator0.writeNumber((long) 2414);
assertEquals(10L, file0.length());
assertEquals(" in a comment0T", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(15, byteArray0.length);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber((short) (byte)53);
assertEquals(" in a comment0T", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals(17L, file0.length());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(15, byteArray0.length);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test017() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "T");
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0T", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(fileDescriptor0);
assertNotNull(mockFileInputStream0);
byte[] byteArray0 = new byte[15];
byteArray0[1] = (byte)0;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(15, byteArrayInputStream0.available());
assertEquals(15, byteArray0.length);
assertNotNull(byteArrayInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, byteArrayInputStream0, true);
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(15, byteArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
byte[] byteArray1 = iOContext0.allocReadIOBuffer();
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(15, byteArray0.length);
assertEquals(8000, byteArray1.length);
assertNotSame(byteArray0, byteArray1);
assertNotSame(byteArray1, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArray1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2414, (ObjectCodec) null, mockPrintStream0, byteArray0, 2, true);
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0T", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(15, byteArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNumber(1);
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(2L, file0.length());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0T", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(15, byteArray0.length);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.flush();
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(5L, file0.length());
assertEquals("/tmp/ in a comment0T", file0.toString());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0T", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15, byteArrayInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2414, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(15, byteArray0.length);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
}
@Test(timeout = 4000)
public void test018() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler1);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler1, object0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
char[] charArray0 = iOContext0.allocTokenBuffer(2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(charArray0);
IOContext iOContext2 = new IOContext(bufferRecycler1, bufferRecycler0, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext2);
TokenFilter tokenFilter1 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter1.includeBinary());
assertTrue(tokenFilter1.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertTrue(tokenFilter1.includeRawValue());
assertSame(tokenFilter1, tokenFilter0);
assertNotNull(tokenFilter1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 1, (ObjectCodec) null, mockPrintStream0, byteArray0, 114, true);
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(114, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
DefaultPrettyPrinter defaultPrettyPrinter0 = new DefaultPrettyPrinter(serializedString0);
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(defaultPrettyPrinter0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.setPrettyPrinter(defaultPrettyPrinter0);
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(114, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(114, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator1, tokenFilter0, false, false);
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(114, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(114, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(114, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
filteringGeneratorDelegate0.writeStartArray(1);
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(10L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertSame(tokenFilter0, tokenFilter1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeEndArray();
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(10L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91, (byte)32, (byte)93, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0._writePPFieldName("g");
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(10L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91, (byte)32, (byte)93, (byte)44, (byte)10, (byte)103, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test019() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler1);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler1, object0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
char[] charArray0 = iOContext0.allocTokenBuffer(2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(charArray0);
IOContext iOContext2 = new IOContext(bufferRecycler1, bufferRecycler0, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext2, (-4481), (ObjectCodec) null, mockPrintStream1, byteArray0, 1742, false);
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1742, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
IOContext iOContext3 = new IOContext(bufferRecycler1, iOContext0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext3, 308, (ObjectCodec) null, mockPrintStream1, byteArray0, 1, false);
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(308, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1.writeString("_0|a*[2Xm%WsA]N?y");
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(20L, file0.length());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(308, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34, (byte)37, (byte)87, (byte)115, (byte)65, (byte)93, (byte)78, (byte)127, (byte)63, (byte)121}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator1._writePPFieldName("_0|a*[2Xm%WsA]N?y");
// 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 test020() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(0);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[0];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayOutputStream0, byteArray0, 2, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
ByteArrayOutputStream byteArrayOutputStream1 = (ByteArrayOutputStream)uTF8JsonGenerator0.getOutputTarget();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayOutputStream1.size());
assertEquals("", byteArrayOutputStream1.toString());
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertSame(byteArrayOutputStream0, byteArrayOutputStream1);
assertSame(byteArrayOutputStream1, byteArrayOutputStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(byteArrayOutputStream1);
IOContext iOContext1 = new IOContext(bufferRecycler0, byteArrayOutputStream1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayOutputStream1.size());
assertEquals("", byteArrayOutputStream1.toString());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext1);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 110, 412);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ByteArrayOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test021() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)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);
assertNotNull(bufferRecycler1);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler1, object0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
char[] charArray0 = iOContext0.allocTokenBuffer(2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
IOContext iOContext2 = new IOContext(bufferRecycler1, bufferRecycler0, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext2, (-4481), (ObjectCodec) null, mockPrintStream1, byteArray0, 1742, false);
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1742, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeFieldName(" in a comment");
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(20L, file0.length());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)109, (byte)101, (byte)110, (byte)116, (byte)34, (byte)97, (byte)32, (byte)99, (byte)111, (byte)109}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(false);
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(25L, file0.length());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)102, (byte)97, (byte)108, (byte)115, (byte)101, (byte)97, (byte)32, (byte)99, (byte)111, (byte)109}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(true);
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(31L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)116, (byte)114, (byte)117, (byte)101, (byte)101, (byte)32, (byte)32, (byte)99, (byte)111, (byte)109}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test022() throws Throwable {
File file0 = MockFile.createTempFile("{$5k^_C#l?Ro];2", "_0|a*[2Xm%WsA]N?y");
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("{$5k^_C#l?Ro];20_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp/{$5k^_C#l?Ro];20_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(mockPrintStream0);
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("{$5k^_C#l?Ro];20_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(4L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp/{$5k^_C#l?Ro];20_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isFile());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertNotNull(objectOutputStream0);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte) (-123);
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)2;
byteArray0[3] = (byte)50;
byteArray0[4] = (byte)19;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 40, (ObjectCodec) null, objectOutputStream0, byteArray0, 97, false);
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("{$5k^_C#l?Ro];20_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(4L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp/{$5k^_C#l?Ro];20_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isFile());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(40, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(97, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-123), (byte)0, (byte)2, (byte)50, (byte)19}, byteArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertNotNull(bigInteger0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((-1800L));
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ObjectOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test023() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, true);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeStartArray();
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
char[] charArray0 = new char[9];
charArray0[2] = '?';
charArray0[0] = '4';
charArray0[1] = 'h';
charArray0[6] = 'T';
uTF8JsonGenerator0.writeString(charArray0, 614, 0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(2L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertEquals(9, charArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertArrayEquals(new char[] {'4', 'h', '?', '\u0000', '\u0000', '\u0000', 'T', '\u0000', '\u0000'}, charArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(fileDescriptor0);
assertNotNull(mockFileInputStream0);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream(mockFileInputStream0, 57343);
assertFalse(fileDescriptor0.valid());
assertNotNull(pushbackInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((Base64Variant) null, (InputStream) pushbackInputStream0, 3);
// 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 test024() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
BufferedInputStream bufferedInputStream0 = new BufferedInputStream((InputStream) null, 7976);
assertNotNull(bufferedInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferedInputStream0, true);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("IZV`0x{Tp3IR<M*c", true);
assertNotNull(mockFileOutputStream0);
BufferedOutputStream bufferedOutputStream0 = new BufferedOutputStream(mockFileOutputStream0);
assertNotNull(bufferedOutputStream0);
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(bufferedOutputStream0);
assertNotNull(objectOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-179), (ObjectCodec) null, objectOutputStream0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((-179), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNumberField("IZV`0x{Tp3IR<M*c", 0L);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((-179), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeRaw("IZV`0x{Tp3IR<M*c");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((-179), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(37, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
bufferRecycler0.allocCharBuffer(56320, 2);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 56320
// //
// verifyException("com.fasterxml.jackson.core.util.BufferRecycler", e);
// }
}
@Test(timeout = 4000)
public void test025() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = null;
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
byte[] byteArray0 = new byte[13];
byteArray0[0] = (byte)83;
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)83;
byte[] byteArray1 = iOContext0.allocWriteEncodingBuffer((int) (byte)83);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(8000, byteArray1.length);
assertNotSame(byteArray1, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray1);
byteArray0[3] = (byte)83;
objectArray0[0] = (Object) (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, mockPrintStream0, byteArray0, 2, true);
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(13, byteArray0.length);
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.close();
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test026() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
Object object0 = uTF8JsonGenerator0.getCurrentValue();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
char[] charArray0 = iOContext0.allocTokenBuffer(974);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
PipedInputStream pipedInputStream0 = new PipedInputStream(pipedOutputStream0, 57343);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pushbackInputStream0);
IOContext iOContext2 = new IOContext(bufferRecycler0, pushbackInputStream0, true);
assertEquals(0, pipedInputStream0.available());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
IOContext iOContext3 = new IOContext(bufferRecycler0, iOContext1, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext3);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-51);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext3, 0, (ObjectCodec) null, pipedOutputStream0, byteArray0, 56320, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(56320, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFeatureMask());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-51)}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeBoolean(true);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test027() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)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);
assertNotNull(bufferRecycler1);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler1, object0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
char[] charArray0 = iOContext0.allocTokenBuffer(2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(charArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, false);
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary(byteArray0, 3, 3574);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 10
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test028() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" i a cmment", " i a cmment");
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
PrintStream printStream0 = mockPrintStream0.append((CharSequence) " i a cmment");
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(11L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
Enumeration<SequenceInputStream> enumeration0 = (Enumeration<SequenceInputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
byte[] byteArray0 = new byte[1];
byte byte0 = (byte)113;
byteArray0[0] = (byte)113;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(1, byteArrayInputStream0.available());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)113}, byteArray0);
assertNotNull(byteArrayInputStream0);
FilterOutputStream filterOutputStream0 = new FilterOutputStream(printStream0);
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(11L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(filterOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 115, (ObjectCodec) null, filterOutputStream0, byteArray0, 2, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(11L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(115, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)113}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
Object object0 = uTF8JsonGenerator0.getCurrentValue();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(11L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(115, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)113}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext1);
IOContext iOContext2 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext2);
byte[] byteArray1 = iOContext2.allocReadIOBuffer();
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(byteArray1.equals((Object)byteArray0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(8000, byteArray1.length);
assertNotSame(byteArray1, byteArray0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(byteArray1);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)113}, byteArray0);
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.FilterOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test029() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
MockFile mockFile0 = new MockFile("Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow", "");
assertNotNull(mockFile0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Np-/>7%<O`A`=$qy", true);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(readerBasedJsonParser0, tokenFilter0, false, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertEquals(0, filteringParserDelegate0.getFeatureMask());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(filteringParserDelegate0);
ObjectCodec objectCodec0 = filteringParserDelegate0.getCodec();
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertEquals(0, filteringParserDelegate0.getFeatureMask());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(objectCodec0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(mockFile0, true);
assertNotNull(mockFileOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 31, (ObjectCodec) null, mockFileOutputStream0);
assertTrue(mockFile0.isAbsolute());
assertTrue(mockFile0.canExecute());
assertEquals("/experiment", mockFile0.getParent());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals("Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow", mockFile0.getName());
assertEquals("/experiment/Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow", mockFile0.toString());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertTrue(mockFile0.exists());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(1392409281320L, mockFile0.lastModified());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(31, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
PipedInputStream pipedInputStream0 = new PipedInputStream(3);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)74;
byteArray0[1] = (byte) (-2);
byteArray0[2] = (byte)33;
byteArray0[3] = (byte)13;
byteArray0[4] = (byte)23;
// Undeclared exception!
// try {
uTF8JsonGenerator0._writeBinary((Base64Variant) null, pipedInputStream0, byteArray0);
// 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 test030() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", " in a comment");
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
BufferedOutputStream bufferedOutputStream0 = new BufferedOutputStream(mockPrintStream0);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertNotNull(bufferedOutputStream0);
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(bufferedOutputStream0);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertNotNull(objectOutputStream0);
MockPrintStream mockPrintStream1 = new MockPrintStream(objectOutputStream0, true);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, (Object) null, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
byte[] byteArray0 = new byte[0];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext2, 85, (ObjectCodec) null, objectOutputStream0, byteArray0, 32768, false);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(32768, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(85, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeStartArray();
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ObjectOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test031() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "_0|a*[2Xm%WsA]N?y");
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[9];
MockPrintStream mockPrintStream1 = new MockPrintStream(file0);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
MockPrintStream mockPrintStream2 = new MockPrintStream(mockPrintStream1, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream2.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream2.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream2);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-]43,MgP{", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(9, byteArrayInputStream0.available());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(byteArrayInputStream0);
byteArrayInputStream0.mark(56319);
assertEquals(9, byteArrayInputStream0.available());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-960), (ObjectCodec) null, mockPrintStream0, byteArray0, 2, false);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-960), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream2));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, (-2));
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(11L, file0.length());
assertTrue(file0.canWrite());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, byteArrayInputStream0.available());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-960), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream2));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)65, (byte)65, (byte)65, (byte)65, (byte)34, (byte)65, (byte)105, (byte)0, (byte)0}, byteArray0);
assertEquals(9, int0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, mockPrintStream2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName("_0|a*[2Xm%WsA]N?y");
// 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 test032() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean0 = file0.createNewFile();
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(boolean0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, pipedInputStream0, true);
assertEquals(0, pipedInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 512, (ObjectCodec) null, mockPrintStream0);
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(0, pipedInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(512, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeFieldName(" in a comment");
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(0, pipedInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(512, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber(Double.NaN);
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(0, pipedInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(512, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.close();
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(16L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(0, pipedInputStream0.available());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(512, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test033() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
byte byte0 = (byte)21;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.close();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// }
}
@Test(timeout = 4000)
public void test034() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", (String) null);
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format(" in a comment", objectArray0);
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals(13L, file0.length());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[16];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals(13L, file0.length());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals(13L, file0.length());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(filteringGeneratorDelegate0);
uTF8JsonGenerator0.close();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(29L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp");
boolean boolean0 = FileSystemHandling.appendDataToFile(evoSuiteFile0, byteArray0);
assertEquals(16, byteArray0.length);
assertFalse(boolean0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotNull(serializedString0);
byte[] byteArray1 = serializedString0.asQuotedUTF8();
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(29L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(byteArray1.equals((Object)byteArray0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray1.length);
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray1);
assertNotSame(byteArray1, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(byteArray1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(29L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(29L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(29L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0.tmp", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(29L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0.tmp", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(12, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// try {
uTF8JsonGenerator0.writeNumber(383);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a number, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test035() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
ObjectCodec objectCodec0 = null;
String string0 = "";
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
MockPrintStream mockPrintStream1 = new MockPrintStream(" in a comment");
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, file0, false);
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 99, (ObjectCodec) null, mockPrintStream1);
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)88;
byteArray0[1] = (byte) (-13);
byteArray0[2] = (byte)46;
// Undeclared exception!
// try {
uTF8JsonGenerator0._writeBinary((Base64Variant) null, byteArray0, 1336, (byte)88);
// 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 test036() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)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);
assertNotNull(bufferRecycler1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
uTF8JsonGenerator0.writeNumberField("_\n{8D#d%97xJ H.*", Double.POSITIVE_INFINITY);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(25, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test037() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
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);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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);
assertNotNull(iOContext0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
pipedOutputStream0.flush();
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(0);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)51;
byteArray0[1] = (byte)57;
byteArray0[2] = (byte)52;
byteArray0[3] = (byte) (-45);
byteArray0[4] = (byte)18;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-5180), (ObjectCodec) null, byteArrayOutputStream0, byteArray0, (byte)18, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-5180), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)51, (byte)57, (byte)52, (byte) (-45), (byte)18}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((-1807.0F));
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ByteArrayOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test038() throws Throwable {
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
File file1 = MockFile.createTempFile(" in a comment", " in a comment");
assertFalse(file1.isDirectory());
assertEquals(0L, file1.getFreeSpace());
assertTrue(file1.exists());
assertEquals(" in a comment1 in a comment", file1.getName());
assertEquals(0L, file1.getTotalSpace());
assertEquals(1392409281320L, file1.lastModified());
assertEquals(0L, file1.length());
assertTrue(file1.canExecute());
assertTrue(file1.canRead());
assertEquals("/tmp", file1.getParent());
assertTrue(file1.isAbsolute());
assertTrue(file1.isFile());
assertTrue(file1.canWrite());
assertFalse(file1.isHidden());
assertEquals(0L, file1.getUsableSpace());
assertEquals("/tmp/ in a comment1 in a comment", file1.toString());
assertFalse(file1.equals((Object)file0));
assertNotSame(file1, file0);
assertNotNull(file1);
MockPrintStream mockPrintStream2 = new MockPrintStream(file1);
assertFalse(file1.equals((Object)file0));
assertFalse(mockPrintStream2.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream2.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream2);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(10, byteArrayInputStream0.available());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(byteArrayInputStream0);
byteArrayInputStream0.mark(23);
assertEquals(10, byteArrayInputStream0.available());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
int int0 = 48;
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "_0|a*[2Xm%WsA]N?y", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 500, (ObjectCodec) null, mockPrintStream0, byteArray0, 255, false);
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(255, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(500, uTF8JsonGenerator0.getFeatureMask());
assertFalse(file0.equals((Object)file1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream2));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
// try {
uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 500);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Too few bytes available: missing 490 bytes (out of 500)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test039() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
pipedOutputStream0.flush();
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertNotNull(serializedString0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(0);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, byteArrayOutputStream0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
int int0 = (-1785);
char[] charArray0 = new char[4];
int int1 = uTF8JsonGenerator0.getOutputBuffered();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(int1 == int0);
assertEquals(0, int1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
charArray0[0] = 'j';
charArray0[1] = '\\';
charArray0[2] = '';
charArray0[3] = ']';
// Undeclared exception!
// try {
iOContext0.releaseConcatBuffer(charArray0);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test040() throws Throwable {
ObjectCodec objectCodec0 = null;
MockFile mockFile0 = new MockFile(" in a comment");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream(mockFile0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
FileDescriptor fileDescriptor0 = new FileDescriptor();
assertFalse(fileDescriptor0.valid());
assertNotNull(fileDescriptor0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(fileDescriptor0);
assertNotNull(mockFileInputStream0);
BufferedInputStream bufferedInputStream0 = new BufferedInputStream(mockFileInputStream0);
assertFalse(fileDescriptor0.valid());
assertNotNull(bufferedInputStream0);
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(bufferedInputStream0, bufferedInputStream0);
assertFalse(fileDescriptor0.valid());
assertNotNull(sequenceInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, sequenceInputStream0, true);
assertFalse(fileDescriptor0.valid());
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(mockPrintStream0);
assertFalse(mockFile0.isAbsolute());
assertEquals(" in a comment", mockFile0.getName());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canRead());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.exists());
assertTrue(mockFile0.isFile());
assertFalse(mockFile0.isHidden());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isDirectory());
assertEquals(" in a comment", mockFile0.toString());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(4L, mockFile0.length());
assertTrue(mockFile0.canExecute());
assertNotNull(objectOutputStream0);
byte[] byteArray0 = new byte[7];
byte byte0 = (byte)101;
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
byteArray0[0] = (byte)101;
byteArray0[1] = (byte)19;
byteArray0[2] = (byte)101;
byteArray0[5] = (byte)19;
byteArray0[6] = (byte)101;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (byte)19, (ObjectCodec) null, objectOutputStream0, byteArray0, (byte)101, true);
assertFalse(mockFile0.isAbsolute());
assertEquals(" in a comment", mockFile0.getName());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canRead());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.exists());
assertTrue(mockFile0.isFile());
assertFalse(mockFile0.isHidden());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isDirectory());
assertEquals(" in a comment", mockFile0.toString());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(4L, mockFile0.length());
assertTrue(mockFile0.canExecute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(19, uTF8JsonGenerator0.getFeatureMask());
assertEquals(101, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(fileDescriptor0.valid());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(7, byteArray0.length);
assertArrayEquals(new byte[] {(byte)101, (byte)19, (byte)101, (byte)0, (byte)0, (byte)19, (byte)101}, byteArray0);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber(2);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ObjectOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test041() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 56320);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertNotNull(bigInteger0);
// try {
uTF8JsonGenerator0.writeNumber(bigInteger0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a number, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test042() throws Throwable {
byte[] byteArray0 = new byte[5];
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
MockFile mockFile0 = new MockFile(" in a comment", " in a comment");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream(mockFile0);
assertNotNull(mockPrintStream0);
FilterOutputStream filterOutputStream0 = new FilterOutputStream(mockPrintStream0);
assertTrue(mockFile0.isAbsolute());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canExecute());
assertEquals("/experiment/ in a comment/ in a comment", mockFile0.toString());
assertEquals("/experiment/ in a comment", mockFile0.getParent());
assertEquals(" in a comment", mockFile0.getName());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertNotNull(filterOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-3239), (ObjectCodec) null, filterOutputStream0, byteArray0, (-3239), false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(mockFile0.isAbsolute());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canExecute());
assertEquals("/experiment/ in a comment/ in a comment", mockFile0.toString());
assertEquals("/experiment/ in a comment", mockFile0.getParent());
assertEquals(" in a comment", mockFile0.getName());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-3239), uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-3239), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.flush();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(mockFile0.isAbsolute());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canExecute());
assertEquals("/experiment/ in a comment/ in a comment", mockFile0.toString());
assertEquals("/experiment/ in a comment", mockFile0.getParent());
assertEquals(" in a comment", mockFile0.getName());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getUsableSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.canWrite());
assertFalse(mockFile0.isHidden());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-3239), uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-3239), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
PipedInputStream pipedInputStream0 = new PipedInputStream(pipedOutputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
BufferedInputStream bufferedInputStream0 = new BufferedInputStream(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(bufferedInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((Base64Variant) null, (InputStream) bufferedInputStream0, 614);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -3239
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test043() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "_0|a*[2Xm%WsA]N?y");
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[16];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "_0|a*[2Xm%WsA]N?y", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 635, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, false);
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(635, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(16, byteArray0.length);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
char[] charArray0 = new char[8];
charArray0[0] = '-';
charArray0[1] = '1';
charArray0[2] = '-';
charArray0[3] = '1';
charArray0[4] = '?';
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(16, byteArray0.length);
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(635, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(16, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 2, 117);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 16
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test044() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean0 = file0.createNewFile();
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(boolean0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 2961);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext0 = new IOContext(bufferRecycler0, pipedInputStream0, true);
assertEquals(0, pipedInputStream0.available());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("0=", true);
assertNotNull(mockFileOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, mockFileOutputStream0, byteArrayBuilder0.NO_BYTES, 7, true);
assertEquals(0, pipedInputStream0.available());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// try {
uTF8JsonGenerator0.writeStartObject();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Error in writing to file
// //
// verifyException("org.evosuite.runtime.mock.java.io.NativeMockedIO", e);
// }
}
@Test(timeout = 4000)
public void test045() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
MockFile mockFile0 = new MockFile(", expecting field name");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream(mockFile0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
int int0 = 949;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(", expecting field name", mockFile0.getName());
assertNull(mockFile0.getParent());
assertFalse(mockFile0.isAbsolute());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canExecute());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeFieldName("W&h{4d");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(", expecting field name", mockFile0.getName());
assertNull(mockFile0.getParent());
assertFalse(mockFile0.isAbsolute());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canExecute());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeString("sXd+!m#");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(", expecting field name", mockFile0.getName());
assertNull(mockFile0.getParent());
assertFalse(mockFile0.isAbsolute());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canExecute());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
char[] charArray0 = new char[8];
charArray0[0] = '\u0082';
charArray0[1] = '\u0082';
charArray0[2] = 'R';
charArray0[3] = 'r';
charArray0[4] = 'r';
charArray0[5] = '\u0082';
charArray0[6] = 'r';
charArray0[7] = '\u0082';
uTF8JsonGenerator0.writeString(charArray0, 0, 2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(mockFile0.isDirectory());
assertEquals(0L, mockFile0.length());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(", expecting field name", mockFile0.getName());
assertNull(mockFile0.getParent());
assertFalse(mockFile0.isAbsolute());
assertTrue(mockFile0.canWrite());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertEquals(0L, mockFile0.getUsableSpace());
assertFalse(mockFile0.isHidden());
assertTrue(mockFile0.canExecute());
assertEquals(", expecting field name", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.exists());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(22, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(8, charArray0.length);
assertArrayEquals(new char[] {'\u0082', '\u0082', 'R', 'r', 'r', '\u0082', 'r', '\u0082'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// try {
uTF8JsonGenerator0.writeFieldName(" Lk#-FHW=I7{XwvGh]");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test046() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[16];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 78, (ObjectCodec) null, mockPrintStream0, byteArray0, 2260, true);
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(2260, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(78, uTF8JsonGenerator1.getFeatureMask());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(16, byteArray0.length);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator0.writeString("");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(16L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(16, byteArray0.length);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// try {
uTF8JsonGenerator1.writeEndObject();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an object but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test047() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
pipedOutputStream0.close();
pipedOutputStream0.flush();
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)105;
byteArray0[1] = (byte)15;
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
BigInteger bigInteger0 = BigInteger.ONE;
assertEquals((short)1, bigInteger0.shortValue());
assertEquals((byte)1, bigInteger0.byteValue());
assertNotNull(bigInteger0);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
Enumeration<SequenceInputStream> enumeration0 = (Enumeration<SequenceInputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, sequenceInputStream0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 110, (ObjectCodec) null, pipedOutputStream0, byteArray0, 2, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(110, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)105, (byte)15}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
// try {
uTF8JsonGenerator0.writeNumber((double) (byte)15);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test048() throws Throwable {
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertFalse(boolean1 == boolean0);
assertTrue(boolean1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)107;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-1433), (ObjectCodec) null, (OutputStream) null, byteArray0, 3223, false);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3223, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-1433), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)107}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((float) 3);
// 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 test049() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[16];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
uTF8JsonGenerator0.close();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(16L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp");
byte[] byteArray1 = new byte[3];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray0[0] = (byte) (-99);
byteArray1[2] = (byte) (-14);
boolean boolean0 = FileSystemHandling.appendDataToFile(evoSuiteFile0, byteArray1);
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(3, byteArray1.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte) (-14)}, byteArray1);
assertFalse(boolean0);
assertNotSame(byteArray1, byteArray0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(16L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(16L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName("was expecting a colon to separate field name and value");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(64L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray1, 126, 0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test050() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "_0|a*[2Xm%WsA]N?y");
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[16];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-]43,MgP{", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(16, byteArrayInputStream0.available());
assertEquals(16, byteArray0.length);
assertNotNull(byteArrayInputStream0);
byteArrayInputStream0.mark(3);
assertEquals(16, byteArrayInputStream0.available());
assertEquals(16, byteArray0.length);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream1, byteArray0, 46, true);
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(46, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(16, byteArray0.length);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(16, byteArray0.length);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(16L, file0.length());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(16, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(16L, file0.length());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(16, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber(13);
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(21L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(16, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test051() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler1);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler1, object0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
char[] charArray0 = iOContext0.allocTokenBuffer(2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
IOContext iOContext2 = new IOContext(bufferRecycler1, bufferRecycler0, false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext2, (-4481), (ObjectCodec) null, mockPrintStream1, byteArray0, 73, false);
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(73, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeBoolean(false);
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(10L, file0.length());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)102, (byte)97, (byte)108, (byte)115, (byte)101, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString(charArray0, 85, 3);
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(29L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertEquals(4000, charArray0.length);
assertArrayEquals(new byte[] {(byte)92, (byte)117, (byte)48, (byte)48, (byte)48, (byte)48, (byte)34, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0._verifyValueWrite(" in a comment");
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(29L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-4481), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)92, (byte)117, (byte)48, (byte)48, (byte)48, (byte)48, (byte)34, (byte)32, (byte)0, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test052() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "_0|a*[2Xm%WsA]N?y");
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[10];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-1041), (ObjectCodec) null, mockPrintStream1, byteArray0, (-4665), false);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-1041), uTF8JsonGenerator0.getFeatureMask());
assertEquals((-4665), uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-1041), uTF8JsonGenerator0.getFeatureMask());
assertEquals((-4665), uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals((-4665), filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(filteringGeneratorDelegate0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext2);
MockPrintStream mockPrintStream2 = new MockPrintStream(mockPrintStream1, false);
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream2.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream2.equals((Object)mockPrintStream1));
assertNotNull(mockPrintStream2);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, (-1), (ObjectCodec) null, mockPrintStream1, byteArray0, 2, true);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-1), uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream2));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1.writeNumber((long) 3);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(2L, file0.length());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(3, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-1), uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream2));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34, (byte)51, (byte)34, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, mockPrintStream2);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(mockPrintStream1, mockPrintStream2);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator1.writeNumber((short)42);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(6L, file0.length());
assertEquals("/tmp/ in a comment0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0_0|a*[2Xm%WsA]N?y", file0.getName());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(4, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-1), uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream2));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(10, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34, (byte)52, (byte)50, (byte)34, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, mockPrintStream2);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(mockPrintStream1, mockPrintStream2);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test053() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "_0|a*[2Xm%WsA]N?y");
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[16];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, mockPrintStream0, false);
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2048, (ObjectCodec) null, mockPrintStream1, byteArray0, 1, true);
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2048, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(16, byteArray0.length);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger1 = new BigInteger(byteArray0);
assertEquals((short)0, bigInteger1.shortValue());
assertEquals((byte)0, bigInteger1.byteValue());
assertFalse(bigInteger1.equals((Object)bigInteger0));
assertEquals(16, byteArray0.length);
assertNotNull(bigInteger1);
IOContext iOContext1 = new IOContext(bufferRecycler0, "-]43,MgP{", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, (-1037), (ObjectCodec) null, mockPrintStream1);
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals((-1037), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1.writeNumber(bigInteger1);
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertEquals((short)0, bigInteger1.shortValue());
assertEquals((byte)0, bigInteger1.byteValue());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals((-1037), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(bigInteger1.equals((Object)bigInteger0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(16, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(bigInteger1, bigInteger0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeUTF8String(byteArray0, 1, 3);
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(0L, file0.length());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertTrue(file0.canExecute());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2048, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(9, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(16, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
}
@Test(timeout = 4000)
public void test054() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeStartArray();
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 0, 614);
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
char[] charArray0 = new char[9];
charArray0[0] = '_';
charArray0[1] = 'L';
charArray0[2] = '?';
charArray0[3] = '4';
charArray0[4] = ':';
charArray0[5] = 'h';
charArray0[6] = 'T';
charArray0[7] = 'o';
charArray0[8] = '0';
uTF8JsonGenerator0.writeString(charArray0, 614, 0);
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertEquals(6L, file0.length());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertEquals(9, charArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertArrayEquals(new char[] {'_', 'L', '?', '4', ':', 'h', 'T', 'o', '0'}, charArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString0);
// 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 test055() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 56320);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// try {
uTF8JsonGenerator1.writeRawUTF8String(byteArrayBuilder0.NO_BYTES, 614, 512);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a string, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test056() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
pipedOutputStream0.flush();
String string0 = "";
pipedOutputStream0.close();
byte[] byteArray0 = new byte[0];
boolean boolean1 = true;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, pipedOutputStream0, byteArray0, 1, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// try {
uTF8JsonGenerator0.writeNumber((short) (-4122));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test057() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
ObjectCodec objectCodec0 = null;
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[5];
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext2 = new IOContext(bufferRecycler1, iOContext0, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext2);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext3, 51, (ObjectCodec) null, pipedOutputStream0, byteArray0, 1293, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1293, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(51, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "is@m`tgO$hUBd4h{";
// try {
uTF8JsonGenerator0.writeString("is@m`tgO$hUBd4h{");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test058() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "(XXjS`n.PJt");
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0(XXjS`n.PJt", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0(XXjS`n.PJt", file0.getName());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)102;
byteArray0[2] = (byte)71;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(3, byteArrayInputStream0.available());
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)102, (byte)71}, byteArray0);
assertNotNull(byteArrayInputStream0);
byteArrayInputStream0.mark((-105));
assertEquals(3, byteArrayInputStream0.available());
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)102, (byte)71}, byteArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 78, (ObjectCodec) null, mockPrintStream0, byteArray0, 78, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0(XXjS`n.PJt", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0(XXjS`n.PJt", file0.getName());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(78, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(78, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)102, (byte)71}, byteArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, (int) (byte)109);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 3
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test059() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
pipedOutputStream0.flush();
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, (Object) null, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[2];
byte byte0 = (byte) (-126);
byteArray0[0] = (byte) (-126);
byte byte1 = (byte) (-64);
byteArray0[1] = (byte) (-64);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-99), (ObjectCodec) null, pipedOutputStream0, byteArray0, 3128, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-99), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3128, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-126), (byte) (-64)}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
// try {
uTF8JsonGenerator0.writeStartArray();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test060() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
pipedOutputStream0.flush();
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler1);
PipedInputStream pipedInputStream0 = new PipedInputStream(37);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
IOContext iOContext1 = new IOContext(bufferRecycler1, pipedInputStream0, false);
assertEquals(0, pipedInputStream0.available());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, pipedInputStream0.available());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)111;
byteArray0[1] = (byte)53;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext2, 37, (ObjectCodec) null, pipedOutputStream0, byteArray0, 45, false);
assertEquals(0, pipedInputStream0.available());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(37, uTF8JsonGenerator0.getFeatureMask());
assertEquals(45, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)111, (byte)53}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertNotNull(bigInteger0);
byte[] byteArray1 = iOContext2.allocWriteEncodingBuffer(0);
assertEquals(0, pipedInputStream0.available());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(8000, byteArray1.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(byteArray1, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArray1);
// try {
uTF8JsonGenerator0.writeNumber((long) (byte)53);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test061() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "_0|a*[2Xm%WsA]N?y");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[16];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-]43,MgP{", false);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(16, byteArrayInputStream0.available());
assertEquals(16, byteArray0.length);
assertNotNull(byteArrayInputStream0);
byteArrayInputStream0.mark(3);
assertEquals(16, byteArrayInputStream0.available());
assertEquals(16, byteArray0.length);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-3242), (ObjectCodec) null, mockPrintStream0, byteArray0, 2, false);
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.canExecute());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-3242), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(16, byteArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, (-1486));
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(23L, file0.length());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertTrue(file0.canExecute());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, byteArrayInputStream0.available());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-3242), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(16, byteArray0.length);
assertEquals(16, int0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName("-]43,MgP{");
// 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 test062() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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);
assertNotNull(iOContext0);
String string0 = " i a cmment";
File file0 = MockFile.createTempFile(" i a cmment", " i a cmment");
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
PrintStream printStream0 = mockPrintStream0.append((CharSequence) " i a cmment");
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(11L, file0.length());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(11L, file0.length());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary(byteArray0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test063() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
MockFileInputStream mockFileInputStream0 = new MockFileInputStream(file0);
assertNotNull(mockFileInputStream0);
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(mockFileInputStream0, mockFileInputStream0);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, mockFileInputStream0.available());
assertNotNull(sequenceInputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, sequenceInputStream0, false);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-5731), (ObjectCodec) null, pipedOutputStream0);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals((-5731), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals((-5731), uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)126;
byteArray0[1] = (byte)14;
byteArray0[2] = (byte)14;
byteArray0[3] = (byte)14;
byteArray0[4] = (byte)14;
byteArray0[5] = (byte)126;
byteArray0[6] = (byte)126;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(7, byteArrayInputStream0.available());
assertEquals(7, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)14, (byte)14, (byte)14, (byte)14, (byte)126, (byte)126}, byteArray0);
assertNotNull(byteArrayInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 3);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(4, byteArrayInputStream0.available());
assertEquals(0, mockFileInputStream0.available());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals((-5731), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(9, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(7, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)14, (byte)14, (byte)14, (byte)14, (byte)126, (byte)126}, byteArray0);
assertEquals(3, int0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName("");
// 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 test064() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
PrintStream printStream0 = mockPrintStream0.append((CharSequence) null, 0, 1);
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)83;
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)83;
byte[] byteArray1 = iOContext0.allocWriteEncodingBuffer((int) (byte)83);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(8000, byteArray1.length);
assertNotSame(byteArray1, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArray1);
byteArray0[3] = (byte)117;
byteArray0[4] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, mockPrintStream0, byteArray0, 2, true);
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)83, (byte)83, (byte)117, (byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeString((String) null);
assertTrue(file0.canExecute());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(3L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)110, (byte)117, (byte)108, (byte)108, (byte)83}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertNotSame(byteArray0, byteArray1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeNumber((short)2511);
assertTrue(file0.canExecute());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(8L, file0.length());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)50, (byte)53, (byte)49, (byte)49, (byte)32}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertNotSame(byteArray0, byteArray1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._releaseBuffers();
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test065() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(1);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
MockPrintStream mockPrintStream0 = new MockPrintStream(byteArrayOutputStream0, false);
assertNotNull(mockPrintStream0);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler1, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)112;
int int0 = 536870908;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, mockPrintStream1, byteArray0, 536870908, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(536870908, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)112}, byteArray0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)112, bigInteger0.byteValue());
assertEquals((short)112, bigInteger0.shortValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)112}, byteArray0);
assertNotNull(bigInteger0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, (-3), (ObjectCodec) null, mockPrintStream0, byteArray0, 2, true);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertEquals((-3), uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)112}, byteArray0);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
BigInteger bigInteger1 = new BigInteger(byteArray0);
assertEquals((short)112, bigInteger1.shortValue());
assertEquals((byte)112, bigInteger1.byteValue());
assertTrue(bigInteger1.equals((Object)bigInteger0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)112}, byteArray0);
assertNotNull(bigInteger1);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber(bigInteger0);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ByteArrayOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test066() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(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.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler1, 2);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
BufferRecycler bufferRecycler2 = new BufferRecycler();
assertFalse(bufferRecycler2.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler2);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArrayBuilder0.NO_BYTES);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, byteArrayInputStream0.available());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler2));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayInputStream0);
IOContext iOContext1 = new IOContext(bufferRecycler2, byteArrayInputStream0, true);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, byteArrayInputStream0.available());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler2));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler2));
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler2);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext1, 55, (ObjectCodec) null, (OutputStream) null, byteArrayBuilder0.NO_BYTES, 3300, true);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, byteArrayInputStream0.available());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(55, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertEquals(3300, uTF8JsonGenerator2.getOutputBuffered());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler2));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler2.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator2);
// Undeclared exception!
// try {
uTF8JsonGenerator2.writeStartObject();
// 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 test067() throws Throwable {
File file0 = MockFile.createTempFile("-]43,MgP{", "_0|a*[2Xm%WsA]N?y");
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[16];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "-]43,MgP{", false);
assertFalse(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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.length());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(16, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(16, byteArray0.length);
assertNotNull(bigInteger0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 1, (ObjectCodec) null, mockPrintStream1, byteArray0, (-1547), false);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.length());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals((-1547), uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(16, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
BigInteger bigInteger1 = new BigInteger(byteArray0);
assertEquals((short)0, bigInteger1.shortValue());
assertEquals((byte)0, bigInteger1.byteValue());
assertTrue(bigInteger1.equals((Object)bigInteger0));
assertEquals(16, byteArray0.length);
assertNotNull(bigInteger1);
uTF8JsonGenerator0.writeNumber(bigInteger1);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals("/tmp/-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("-]43,MgP{0_0|a*[2Xm%WsA]N?y", file0.getName());
assertEquals(0L, file0.length());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((short)0, bigInteger1.shortValue());
assertEquals((byte)0, bigInteger1.byteValue());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertTrue(bigInteger1.equals((Object)bigInteger0));
assertEquals(16, byteArray0.length);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(bigInteger1, bigInteger0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 0, 56320);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 16
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test068() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("2.7.7-SNAPSHOT", objectArray0);
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(14L, file0.length());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
PrintStream printStream1 = mockPrintStream0.append((CharSequence) null, 0, 1);
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(15L, file0.length());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream1, printStream0);
assertSame(printStream1, mockPrintStream0);
assertNotNull(printStream1);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)83;
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)83;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(3, byteArrayInputStream0.available());
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)83, (byte)83}, byteArray0);
assertNotNull(byteArrayInputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 8000, (ObjectCodec) null, printStream1, byteArray0, 2, false);
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(15L, file0.length());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(8000, uTF8JsonGenerator0.getFeatureMask());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)83, (byte)83}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 0);
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(18L, file0.length());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(3, byteArrayInputStream0.available());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(8000, uTF8JsonGenerator0.getFeatureMask());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34, (byte)83, (byte)34}, byteArray0);
assertEquals(0, int0);
assertSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(iOContext1, iOContext0);
assertSame(printStream1, printStream0);
assertSame(printStream1, mockPrintStream0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName((String) null);
// 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 test069() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[1];
boolean boolean0 = file0.createNewFile();
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertTrue(boolean0);
SerializedString serializedString0 = new SerializedString(" in a comment");
assertEquals(" in a comment", serializedString0.toString());
assertEquals(13, serializedString0.charLength());
assertEquals(" in a comment", serializedString0.getValue());
assertNotNull(serializedString0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, (Object) null, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray1 = iOContext1.allocWriteEncodingBuffer(3660);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(8000, byteArray1.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(byteArray1, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArray1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 92, (ObjectCodec) null, mockPrintStream0, byteArray0, 1, false);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(92, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeString("");
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(2L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(92, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(byteArray0, byteArray1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// try {
uTF8JsonGenerator0.writeEndObject();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an object but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test070() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(textBuffer0);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray0);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString1 = new SerializedString("yeANgQ");
assertEquals(6, serializedString1.charLength());
assertEquals("yeANgQ", serializedString1.toString());
assertEquals("yeANgQ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((char[]) null, 2, 1000);
// 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 test071() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 138, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
uTF8JsonGenerator0.writeNumberField("", (float) 2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals(5L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
filteringGeneratorDelegate0.writeStartArray(0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(7L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 1, 0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(9L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber(3);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(11L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)51}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeEndArray();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(12L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber(0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(14L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(138, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test072() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)26;
byteArray0[1] = (byte)26;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(2, byteArrayInputStream0.available());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)26, (byte)26}, byteArray0);
assertNotNull(byteArrayInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, (-139));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayInputStream0.available());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)26, (byte)26}, byteArray0);
assertEquals(2, int0);
assertSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
}
@Test(timeout = 4000)
public void test073() throws Throwable {
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)94;
byteArray0[1] = (byte)116;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(2, byteArrayInputStream0.available());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)94, (byte)116}, byteArray0);
assertNotNull(byteArrayInputStream0);
boolean boolean0 = false;
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
int int0 = (-632);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 30, (ObjectCodec) null, mockPrintStream0, byteArray0, (-755), false);
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(30, uTF8JsonGenerator0.getFeatureMask());
assertEquals((-755), uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)94, (byte)116}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString("S]xhJlL}b}Po)|");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -755
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test074() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(textBuffer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-1286), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals((-1286), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
byte[] byteArray0 = serializedString1.asUnquotedUTF8();
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals((-1286), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(serializedString1, serializedString0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
SerializedString serializedString2 = new SerializedString("F{aUh6x`m!#5zK\"c{r8");
assertEquals(19, serializedString2.charLength());
assertEquals("F{aUh6x`m!#5zK\"c{r8", serializedString2.getValue());
assertEquals("F{aUh6x`m!#5zK\"c{r8", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
char[] charArray0 = new char[5];
charArray0[0] = 'i';
charArray0[1] = '';
charArray0[2] = 'g';
charArray0[3] = 's';
charArray0[4] = 'B';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 0, 105);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 5
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test075() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-4928), (ObjectCodec) null, (OutputStream) null, byteArray0, 79, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((-4928), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(79, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((short)256, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((-835L));
// 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 test076() throws Throwable {
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
MockFile mockFile0 = new MockFile("write a number");
assertNotNull(mockFile0);
byte[] byteArray1 = iOContext0.allocWriteEncodingBuffer(21);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(8000, byteArray1.length);
assertNotSame(byteArray1, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(byteArray1);
ObjectCodec objectCodec0 = null;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(byteArrayBuilder0);
FilterOutputStream filterOutputStream0 = new FilterOutputStream(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(filterOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 13, (ObjectCodec) null, filterOutputStream0, byteArray0, 7, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString("write a number");
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.FilterOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test077() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader(")/@I.b");
assertNotNull(stringReader0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)126;
byteArray0[1] = (byte)26;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(2, byteArrayInputStream0.available());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)26}, byteArray0);
assertNotNull(byteArrayInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, byteArrayInputStream0.available());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)26}, byteArray0);
assertEquals(1, int0);
assertNotSame(iOContext0, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(11, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(11, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(objectCodec0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8, (ObjectCodec) null, (OutputStream) null, byteArray0, 1, false);
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(8, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)26}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
String string0 = null;
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeString((String) null);
// 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 test078() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(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.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 56320);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// try {
uTF8JsonGenerator1.writeNumber(0L);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a number, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test079() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
char[] charArray0 = new char[5];
charArray0[2] = 'o';
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(byteArray0);
charArray0[2] = 'o';
charArray0[2] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 3, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'o', '\u0000', '\u0000'}, charArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
byte[] byteArray1 = new byte[9];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)28;
byteArray1[1] = (byte)28;
byteArray1[2] = (byte)28;
byteArray1[3] = (byte)28;
byteArray1[4] = (byte)28;
byteArray1[5] = (byte)28;
byteArray1[6] = (byte)28;
byteArray1[7] = (byte)28;
byteArray1[8] = (byte)28;
uTF8JsonGenerator0.writeBinary(byteArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(22, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(9, byteArray1.length);
assertArrayEquals(new byte[] {(byte)28, (byte)28, (byte)28, (byte)28, (byte)28, (byte)28, (byte)28, (byte)28, (byte)28}, byteArray1);
assertNotSame(byteArray1, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeStartArray();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(24, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 1);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
byte[] byteArray2 = serializedString0.asUnquotedUTF8();
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertFalse(byteArray2.equals((Object)byteArray1));
assertFalse(byteArray2.equals((Object)byteArray0));
assertEquals(1, byteArray2.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray2);
assertNotSame(byteArray2, byteArray1);
assertNotSame(byteArray2, byteArray0);
assertNotNull(byteArray2);
SerializedString serializedString1 = null;
// try {
serializedString1 = new SerializedString((String) null);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Null String illegal for SerializedString
// //
// verifyException("com.fasterxml.jackson.core.io.SerializedString", e);
// }
}
@Test(timeout = 4000)
public void test080() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 949, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(949, uTF8JsonGenerator0.getFeatureMask());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[6];
charArray0[2] = 'r';
charArray0[3] = 'r';
charArray0[4] = '\u0082';
charArray0[5] = 'Q';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 3, 949);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 6
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test081() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
String string0 = "";
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
int int0 = 126;
byte[] byteArray0 = new byte[1];
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertNotNull(bigInteger0);
boolean boolean1 = false;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, mockPrintStream0, byteArray0, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(2L, file0.length());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(1, byteArrayInputStream0.available());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48}, byteArray0);
assertNotNull(byteArrayInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 614);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test082() throws Throwable {
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
byte[] byteArray1 = new byte[2];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)94;
byteArray1[1] = (byte)116;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray1);
assertEquals(2, byteArrayInputStream0.available());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(2, byteArray1.length);
assertArrayEquals(new byte[] {(byte)94, (byte)116}, byteArray1);
assertNotNull(byteArrayInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 30);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test083() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader(")/@I.b");
assertNotNull(stringReader0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)126;
byteArray0[1] = (byte)26;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(2, byteArrayInputStream0.available());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)26}, byteArray0);
assertNotNull(byteArrayInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, byteArrayInputStream0.available());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)26}, byteArray0);
assertEquals(1, int0);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName("Unexpected padding character ('");
// 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 test084() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader(")/@I.b");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "e/o=,L$?3bi";
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(11, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeFieldName(")/@I.b");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString1 = new SerializedString("ma'");
assertEquals("ma'", serializedString1.toString());
assertEquals(3, serializedString1.charLength());
assertEquals("ma'", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null);
assertNotNull(pushbackInputStream0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 2, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeBinary((InputStream) null, 2);
// 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 test085() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 56320);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeArrayFieldStart("Split surrogate on writeRaw() input (last character): first character 0x%4x");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(83, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext1, 35, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator2.getOutputBuffered());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertEquals(35, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator2);
uTF8JsonGenerator1.writeStartObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertEquals(85, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(85, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator2));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator2);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator2._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// try {
uTF8JsonGenerator1.writeString((SerializableString) serializedString1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a string, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test086() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("2.7.7-SNAPSHOT", objectArray0);
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(14L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
int int0 = 55;
byte byte0 = (byte)83;
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-672), (ObjectCodec) null, printStream0, byteArray0, 1, true);
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(14L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-672), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
int int1 = 127;
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 57343, (ObjectCodec) null, printStream0, byteArray0, 2, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(14L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeBinary(byteArray0, 658, 55);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 658
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test087() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = null;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 949, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(949, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[6];
charArray0[2] = 'r';
charArray0[3] = 'r';
charArray0[4] = '\u0082';
charArray0[5] = 'Q';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 0, 949);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 6
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test088() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader(")/@I.b");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
int int0 = (-12);
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(readerBasedJsonParser0, tokenFilter0, true, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(0, filteringParserDelegate0.getFeatureMask());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(filteringParserDelegate0);
ObjectCodec objectCodec0 = filteringParserDelegate0.getCodec();
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertEquals(0, filteringParserDelegate0.getFeatureMask());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(objectCodec0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-789), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-789), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-789), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals((-789), uTF8JsonGenerator1.getFeatureMask());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator1._writePPFieldName(serializedString0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-789), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(3, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals((-789), uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// try {
uTF8JsonGenerator0._writePPFieldName("?|@u+77QT-aHh");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test089() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
String string0 = " i a cmment";
File file0 = MockFile.createTempFile(" i a cmment", " i a cmment");
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
PrintStream printStream0 = mockPrintStream0.append((CharSequence) " i a cmment");
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(11L, file0.length());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canExecute());
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(11L, file0.length());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeBinary(byteArray0, 127, 0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(12L, file0.length());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotNull(serializedString0);
char[] charArray0 = iOContext0.allocTokenBuffer(57343);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(57343, charArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
uTF8JsonGenerator0.writeUTF8String(byteArray0, 1, 0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(15L, file0.length());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(17L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(" i a cmment0 i a cmment", file0.getName());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ i a cmment0 i a cmment", file0.toString());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 3, 3);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test090() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.close();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(3L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 1, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(5L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber(3);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.io.NumberOutput", e);
// }
}
@Test(timeout = 4000)
public void test091() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "e/o=,L$?3bi";
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(25, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(31, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString1 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null, 56319);
assertNotNull(pushbackInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) pushbackInputStream0, 0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(34, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, int0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator1 = null;
// try {
uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 56319, (ObjectCodec) null, (OutputStream) null);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test092() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in Na comment", "k");
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[2] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("k", objectArray0);
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[16];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in Na comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNull(objectCodec0);
uTF8JsonGenerator0.close();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(17L, file0.length());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp");
byte[] byteArray1 = new byte[3];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray0[0] = (byte) (-99);
byteArray1[1] = (byte) (-117);
byteArray1[2] = (byte) (-14);
boolean boolean0 = FileSystemHandling.appendDataToFile(evoSuiteFile0, byteArray1);
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(3, byteArray1.length);
assertArrayEquals(new byte[] {(byte)0, (byte) (-117), (byte) (-14)}, byteArray1);
assertFalse(boolean0);
assertNotSame(byteArray1, byteArray0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(17L, file0.length());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(17L, file0.length());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertSame(serializedString1, serializedString0);
assertNotSame(byteArray0, byteArray1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((double) 3);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(" in Na comment0k", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(17L, file0.length());
assertTrue(file0.canExecute());
assertEquals("/tmp/ in Na comment0k", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(9, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeBinary((Base64Variant) null, byteArray0, 56319, 12);
// 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 test093() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 56320);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext1, 35, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator2.getOutputBuffered());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertEquals(35, uTF8JsonGenerator2.getFeatureMask());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.isClosed());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator2);
// try {
uTF8JsonGenerator1.writeStartObject();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not start an object, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test094() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "k");
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("k", objectArray0);
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[16];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNull(objectCodec0);
uTF8JsonGenerator0.close();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(17L, file0.length());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp");
byte[] byteArray1 = new byte[3];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray0[0] = (byte) (-99);
byteArray1[1] = (byte) (-117);
byteArray1[2] = (byte) (-14);
boolean boolean0 = FileSystemHandling.appendDataToFile(evoSuiteFile0, byteArray1);
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(3, byteArray1.length);
assertArrayEquals(new byte[] {(byte)0, (byte) (-117), (byte) (-14)}, byteArray1);
assertFalse(boolean0);
assertNotSame(byteArray1, byteArray0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(17L, file0.length());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(17L, file0.length());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertSame(serializedString1, serializedString0);
assertNotSame(byteArray0, byteArray1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator1.writeStartObject();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(17L, file0.length());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString2 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString2.getValue());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.toString());
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertSame(serializedString2, serializedString1);
assertSame(serializedString2, serializedString0);
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeFieldName("was expecting a colon to separate field name and value");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(64L, file0.length());
assertEquals(" in a comment0k", file0.getName());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0k", file0.toString());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(16, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
}
@Test(timeout = 4000)
public void test095() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
StringReader stringReader0 = new StringReader(")/@I.b");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideStdFeatures(240, (-934));
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(80, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
TokenFilter tokenFilter1 = tokenFilter0.includeElement((-12));
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertTrue(tokenFilter1.includeNull());
assertTrue(tokenFilter1.includeBinary());
assertTrue(tokenFilter1.includeRawValue());
assertSame(tokenFilter0, tokenFilter1);
assertSame(tokenFilter1, tokenFilter0);
assertNotNull(tokenFilter1);
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(readerBasedJsonParser1, tokenFilter1, true, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(80, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertTrue(tokenFilter1.includeNull());
assertTrue(tokenFilter1.includeBinary());
assertTrue(tokenFilter1.includeRawValue());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertEquals(80, filteringParserDelegate0.getFeatureMask());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(filteringParserDelegate0);
ObjectCodec objectCodec0 = filteringParserDelegate0.getCodec();
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(80, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertTrue(tokenFilter1.includeNull());
assertTrue(tokenFilter1.includeBinary());
assertTrue(tokenFilter1.includeRawValue());
assertNull(filteringParserDelegate0.getLastClearedToken());
assertFalse(filteringParserDelegate0.isExpectedStartObjectToken());
assertFalse(filteringParserDelegate0.isExpectedStartArrayToken());
assertFalse(filteringParserDelegate0.canReadTypeId());
assertEquals(0, filteringParserDelegate0.getCurrentTokenId());
assertNull(filteringParserDelegate0.getCurrentToken());
assertFalse(filteringParserDelegate0.canReadObjectId());
assertFalse(filteringParserDelegate0.requiresCustomCodec());
assertEquals(0, filteringParserDelegate0.getFormatFeatures());
assertFalse(filteringParserDelegate0.hasCurrentToken());
assertEquals(0, filteringParserDelegate0.getMatchCount());
assertEquals(80, filteringParserDelegate0.getFeatureMask());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(tokenFilter0, tokenFilter1);
assertSame(tokenFilter1, tokenFilter0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(objectCodec0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-789), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-789), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-789), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals((-789), uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator0._writePPFieldName("?|@u+77QT-aHh");
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-789), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-12));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
int int0 = (-1166);
MockFile mockFile0 = (MockFile)MockFile.createTempFile(")/@I.b", "e/o=,L$?3bi");
assertFalse(mockFile0.isDirectory());
assertEquals("/tmp/)/@I.b0e", mockFile0.getParent());
assertEquals(0L, mockFile0.length());
assertEquals("o=,L$?3bi", mockFile0.getName());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(1392409281320L, mockFile0.lastModified());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.exists());
assertTrue(mockFile0.isFile());
assertEquals("/tmp/)/@I.b0e/o=,L$?3bi", mockFile0.toString());
assertFalse(mockFile0.isHidden());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canExecute());
assertEquals(0L, mockFile0.getFreeSpace());
assertTrue(mockFile0.canWrite());
assertTrue(mockFile0.isAbsolute());
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = null;
// try {
mockPrintStream0 = new MockPrintStream(mockFile0, "]!TLjeM8P$;]x'X");
// fail("Expecting exception: UnsupportedEncodingException");
// } catch(Throwable e) {
// //
// // ]!TLjeM8P$;]x'X
// //
// verifyException("java.io.PrintStream", e);
// }
}
@Test(timeout = 4000)
public void test096() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
PrintStream printStream0 = mockPrintStream1.append((CharSequence) null, 0, 1);
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals(1L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(printStream0.equals((Object)mockPrintStream0));
assertNotSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertSame(mockPrintStream1, printStream0);
assertNotSame(printStream0, mockPrintStream0);
assertSame(printStream0, mockPrintStream1);
assertNotNull(printStream0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals(1L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)printStream0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals(1L, file0.length());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)printStream0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNull(objectCodec0);
int int0 = 8000;
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeBinary(byteArray0, 57343, 44);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 57343
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test097() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
MockFile mockFile0 = new MockFile("write a number");
assertNotNull(mockFile0);
MockPrintStream mockPrintStream0 = new MockPrintStream(mockFile0);
assertNotNull(mockPrintStream0);
FilterOutputStream filterOutputStream0 = new FilterOutputStream(mockPrintStream0);
assertFalse(mockFile0.isHidden());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canExecute());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.exists());
assertEquals("write a number", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals("write a number", mockFile0.getName());
assertFalse(mockFile0.isDirectory());
assertTrue(mockFile0.canWrite());
assertNotNull(filterOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, filterOutputStream0, byteArray0, 2, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(mockFile0.isHidden());
assertEquals(0L, mockFile0.getUsableSpace());
assertTrue(mockFile0.canExecute());
assertTrue(mockFile0.isFile());
assertTrue(mockFile0.canRead());
assertTrue(mockFile0.exists());
assertEquals("write a number", mockFile0.toString());
assertEquals(1392409281320L, mockFile0.lastModified());
assertNull(mockFile0.getParent());
assertEquals(0L, mockFile0.getTotalSpace());
assertEquals(0L, mockFile0.getFreeSpace());
assertEquals(0L, mockFile0.length());
assertFalse(mockFile0.isAbsolute());
assertEquals("write a number", mockFile0.getName());
assertFalse(mockFile0.isDirectory());
assertTrue(mockFile0.canWrite());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.flush();
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.FilterOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test098() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
String string0 = "e/o=,L$?3bi";
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(74);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)1;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, byteArrayOutputStream0, byteArray0, 97, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(97, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((char[]) null, (int) (byte)1, 1);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ByteArrayOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test099() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 383, (ObjectCodec) null, mockPrintStream0, byteArray0, 55296, false);
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(55296, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((short)21248, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeNumber((long) 1);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 2
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test100() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3233));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
Enumeration<SequenceInputStream> enumeration0 = (Enumeration<SequenceInputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) sequenceInputStream0, (-2407));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(0, int0);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString1);
// 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 test101() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 56, (ObjectCodec) null, pipedOutputStream0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)14;
byteArray0[1] = (byte)14;
byteArray0[2] = (byte)14;
byteArray0[3] = (byte)14;
byteArray0[4] = (byte)14;
byteArray0[5] = (byte)14;
byteArray0[6] = (byte)14;
byteArray0[7] = (byte)14;
byteArray0[8] = (byte)14;
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(9, byteArrayInputStream0.available());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14}, byteArray0);
assertNotNull(byteArrayInputStream0);
int int0 = uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, (-2105));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, byteArrayInputStream0.available());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(21, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14}, byteArray0);
assertEquals(9, int0);
assertSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName("was expecting double-quote to start field name");
// 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 test102() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.length());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("2.7.7-SNAPSHOT", objectArray0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(14L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
PrintStream printStream1 = mockPrintStream1.append((CharSequence) null, 0, 1);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(15L, file0.length());
assertEquals("/tmp", file0.getParent());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(printStream1.equals((Object)printStream0));
assertFalse(printStream1.equals((Object)mockPrintStream0));
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertSame(mockPrintStream1, printStream1);
assertNotSame(printStream1, printStream0);
assertNotSame(printStream1, mockPrintStream0);
assertSame(printStream1, mockPrintStream1);
assertNotNull(printStream1);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 512, (ObjectCodec) null, mockPrintStream1, byteArray0, 0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(15L, file0.length());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(512, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(1, byteArrayInputStream0.available());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(byteArrayInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, (-2407));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test103() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char[] charArray0 = new char[5];
charArray0[0] = '.';
charArray0[2] = 'o';
charArray0[2] = 'o';
charArray0[2] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 3, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'.', '\u0000', 'o', '\u0000', '\u0000'}, charArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
short short0 = (short)127;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((String) null);
// 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 test104() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", " in a comment");
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertNotNull(file0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 2, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(11, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(25, uTF8JsonGenerator0.getOutputBuffered());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString1 = new SerializedString("ma'");
assertEquals(3, serializedString1.charLength());
assertEquals("ma'", serializedString1.toString());
assertEquals("ma'", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null, 55296);
assertNotNull(pushbackInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((InputStream) null, 1);
// 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 test105() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 943, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(943, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.enable(jsonGenerator_Feature0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isHidden());
assertEquals(943, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(943, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
char[] charArray0 = new char[6];
charArray0[0] = '_';
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);
// try {
uTF8JsonGenerator0.writeBinary((InputStream) sequenceInputStream0, 3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Too few bytes available: missing 3 bytes (out of 3)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test106() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
ObjectCodec objectCodec0 = null;
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 56, (ObjectCodec) null, pipedOutputStream0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)14;
byteArray0[1] = (byte)14;
byteArray0[2] = (byte)14;
byteArray0[3] = (byte)14;
byteArray0[4] = (byte)14;
byteArray0[5] = (byte)14;
byteArray0[6] = (byte)14;
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(56, uTF8JsonGenerator0.getFeatureMask());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(9, byteArrayInputStream0.available());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)14, (byte)0, (byte)0}, byteArray0);
assertNotNull(byteArrayInputStream0);
// try {
uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 81);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Too few bytes available: missing 72 bytes (out of 81)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test107() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[5];
byteArray0[2] = (byte)126;
byteArray0[0] = (byte)126;
byteArray0[4] = (byte)14;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 116, (ObjectCodec) null, pipedOutputStream0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(116, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(116, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(116, uTF8JsonGenerator0.getFeatureMask());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
ByteArrayInputStream byteArrayInputStream0 = new ByteArrayInputStream(byteArray0);
assertEquals(5, byteArrayInputStream0.available());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)0, (byte)126, (byte)0, (byte)14}, byteArray0);
assertNotNull(byteArrayInputStream0);
// try {
uTF8JsonGenerator0.writeBinary((InputStream) byteArrayInputStream0, 26);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Too few bytes available: missing 21 bytes (out of 26)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test108() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(2, objectArray0.length);
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(2, objectArray0.length);
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
PrintStream printStream1 = mockPrintStream1.append((CharSequence) null, 0, 1);
assertEquals(" in a comment0", file0.getName());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(printStream1.equals((Object)printStream0));
assertFalse(printStream1.equals((Object)mockPrintStream0));
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(mockPrintStream1, printStream0);
assertSame(mockPrintStream1, printStream1);
assertNotSame(printStream1, printStream0);
assertNotSame(printStream1, mockPrintStream0);
assertSame(printStream1, mockPrintStream1);
assertNotNull(printStream1);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(" in a comment0", file0.getName());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null, (byte)83);
assertNotNull(pushbackInputStream0);
// try {
uTF8JsonGenerator0.writeBinary((InputStream) pushbackInputStream0, 30);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.PushbackInputStream", e);
// }
}
@Test(timeout = 4000)
public void test109() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(200, charArray0.length);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 45, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(45, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asQuotedUTF8();
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(45, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(45, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(45, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber((BigDecimal) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(45, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// try {
uTF8JsonGenerator0._writePPFieldName("");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test110() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-732), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-732), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-732), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals((-732), uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator0._writePPFieldName("GCm0]WW(0'");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-732), uTF8JsonGenerator0.getFeatureMask());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 55296);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
Object object0 = uTF8JsonGenerator0.getOutputTarget();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-732), uTF8JsonGenerator0.getFeatureMask());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(object0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeNumber((short) (-1986));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-732), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-732), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
IOContext iOContext2 = new IOContext(bufferRecycler0, "GCm0]WW(0'", false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext2);
boolean boolean0 = false;
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext2, 57343, (ObjectCodec) null, (OutputStream) null, byteArrayBuilder0.NO_BYTES, 56320, false);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator2.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(56320, uTF8JsonGenerator2.getOutputBuffered());
assertEquals(57343, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator2);
// try {
uTF8JsonGenerator0.writeNumber((double) (short)4763);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a string, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test111() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("/o=,L$?b");
assertEquals("/o=,L$?b", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertEquals("/o=,L$?b", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals("/o=,L$?b", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertEquals("/o=,L$?b", serializedString0.toString());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(10, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3233));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeNumber((short)4763);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertEquals(0, uTF8JsonGenerator2.getOutputBuffered());
assertEquals(57343, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator2.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator2);
uTF8JsonGenerator2.writeRaw('y');
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertEquals(57343, uTF8JsonGenerator2.getFeatureMask());
assertEquals(1, uTF8JsonGenerator2.getOutputBuffered());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator2.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator2, uTF8JsonGenerator0);
assertNotSame(uTF8JsonGenerator2, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(28, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals("/o=,L$?b", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertEquals("/o=,L$?b", serializedString0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigDecimal bigDecimal0 = new BigDecimal((double) 56319);
assertEquals((byte) (-1), bigDecimal0.byteValue());
assertEquals((short) (-9217), bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator1.writeNumber(bigDecimal0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(36, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(36, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals((byte) (-1), bigDecimal0.byteValue());
assertEquals((short) (-9217), bigDecimal0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator2);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0._writePPFieldName(serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(48, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals("/o=,L$?b", serializedString0.getValue());
assertEquals(8, serializedString0.charLength());
assertEquals("/o=,L$?b", serializedString0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
}
@Test(timeout = 4000)
public void test112() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(8000);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(1L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.close();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(3L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp");
byte[] byteArray1 = new byte[3];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte) (-99);
byteArray1[1] = (byte) (-117);
byteArray1[2] = (byte) (-14);
boolean boolean0 = FileSystemHandling.appendDataToFile(evoSuiteFile0, byteArray1);
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(3, byteArray1.length);
assertArrayEquals(new byte[] {(byte) (-99), (byte) (-117), (byte) (-14)}, byteArray1);
assertFalse(boolean0);
assertNotSame(byteArray1, byteArray0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(3L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(6L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(byteArray0, byteArray1);
assertSame(serializedString1, serializedString0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator1.writeStartObject();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(6L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString2 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString2.getValue());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.toString());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(serializedString2, serializedString1);
assertSame(serializedString2, serializedString0);
assertNotNull(serializedString2);
// Undeclared exception!
uTF8JsonGenerator0.writeFieldName("was expecting a colon to separate field name and value");
}
@Test(timeout = 4000)
public void test113() throws Throwable {
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(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);
assertNotNull(iOContext0);
boolean boolean0 = true;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeStartArray();
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 0, 614);
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
byte[] byteArray1 = serializedString0.asUnquotedUTF8();
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(1, byteArray1.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray1);
assertNotSame(byteArray1, byteArray0);
assertNotNull(byteArray1);
SerializedString serializedString1 = new SerializedString("Split surrogate on writeRaw() input (last character): first character 0x%4x");
assertEquals("Split surrogate on writeRaw() input (last character): first character 0x%4x", serializedString1.getValue());
assertEquals(75, serializedString1.charLength());
assertEquals("Split surrogate on writeRaw() input (last character): first character 0x%4x", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test114() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(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);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
IOContext iOContext1 = new IOContext(bufferRecycler0, sequenceInputStream0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext3, (-3541), (ObjectCodec) null, printStream0, byteArray0, 1969, false);
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-3541), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(1969, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-3541), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(3L, file0.length());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
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);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeRaw("");
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-3541), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(3L, file0.length());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
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);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString0);
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-3541), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(4L, file0.length());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray0);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
// try {
uTF8JsonGenerator0.writeFieldName(" in a comment");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test115() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("h5(;g&t01Dx0");
assertEquals("h5(;g&t01Dx0", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertEquals("h5(;g&t01Dx0", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals("h5(;g&t01Dx0", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertEquals("h5(;g&t01Dx0", serializedString0.getValue());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
IOContext iOContext1 = new IOContext(bufferRecycler0, serializedString0, true);
assertEquals("h5(;g&t01Dx0", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertEquals("h5(;g&t01Dx0", serializedString0.getValue());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)63;
byteArray0[1] = (byte) (-7);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 479, (ObjectCodec) null, (OutputStream) null, byteArray0, 2641, true);
assertEquals("h5(;g&t01Dx0", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertEquals("h5(;g&t01Dx0", serializedString0.getValue());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(479, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(2641, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)63, (byte) (-7)}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator0.writeBoolean(true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(19, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
BigDecimal bigDecimal0 = new BigDecimal(0.0);
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeNumber(bigDecimal0);
// 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 test116() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "#");
assertTrue(file0.canExecute());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertFalse(file0.isHidden());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, serializedString0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeStartObject();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(1L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)123}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)123}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
SerializedString serializedString2 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString2.toString());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.getValue());
assertSame(serializedString2, serializedString0);
assertSame(serializedString2, serializedString1);
assertNotNull(serializedString2);
// try {
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a raw (unencoded) value, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test117() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 739, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_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);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_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);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(25, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_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);
boolean boolean1 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, true, true);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
uTF8JsonGenerator0.writeBoolean(true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(30, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_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);
uTF8JsonGenerator0.writeNumber((long) 0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(34, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_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);
SerializedString serializedString1 = new SerializedString("K8xkDiM=QRKi");
assertEquals("K8xkDiM=QRKi", serializedString1.getValue());
assertEquals("K8xkDiM=QRKi", serializedString1.toString());
assertEquals(12, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null, 55296);
assertNotNull(pushbackInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((InputStream) null, 3);
// 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 test118() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[4];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(4, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2831, false);
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2831, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(8000);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1L, file0.length());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.close();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(3L, file0.length());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(3L, file0.length());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator2.getFeatureMask());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator2.getOutputBuffered());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator2);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator1._rootValueSeparator;
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(6L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2831, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator2));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(4, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(serializedString1, serializedString0);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator2);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator2.writeStartObject();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(6L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator2.getFeatureMask());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator2.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator2, uTF8JsonGenerator1);
assertNotSame(uTF8JsonGenerator2, uTF8JsonGenerator0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
SerializedString serializedString2 = (SerializedString)uTF8JsonGenerator1._rootValueSeparator;
assertEquals(" ", serializedString2.toString());
assertEquals(" ", serializedString2.getValue());
assertEquals(1, serializedString2.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(serializedString2, serializedString1);
assertSame(serializedString2, serializedString0);
assertNotNull(serializedString2);
char[] charArray0 = new char[3];
charArray0[0] = '1';
charArray0[1] = '-';
charArray0[2] = '?';
// try {
uTF8JsonGenerator2.writeString(charArray0, (-1910), 12000);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a string, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test119() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 739, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte) (-7);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 739, (ObjectCodec) null, (OutputStream) null, byteArray0, (byte) (-7), true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals((-7), uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(739, uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-7), (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
StringReader stringReader0 = new StringReader("e/o=,L$?3bi");
assertNotNull(stringReader0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(27, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeFieldName((SerializableString) serializedString0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test120() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("2.7.7-SNAPSHOT", objectArray0);
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(14L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(14L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(14L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
int int0 = 0;
PrintStream printStream1 = mockPrintStream1.append((CharSequence) null, 0, 1);
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(15L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertFalse(printStream1.equals((Object)mockPrintStream0));
assertFalse(printStream1.equals((Object)printStream0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertSame(printStream1, mockPrintStream1);
assertNotSame(printStream1, mockPrintStream0);
assertNotSame(printStream1, printStream0);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream1, printStream1);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(mockPrintStream1, printStream0);
assertNotNull(printStream1);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(15L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(15L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
// Undeclared exception!
uTF8JsonGenerator1.writeFieldName("2.7.7-SNAPSHOT");
}
@Test(timeout = 4000)
public void test121() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(3);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext2);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)124;
byteArray0[1] = (byte)125;
byteArray0[2] = (byte) (-113);
byteArray0[3] = (byte)17;
byteArray0[4] = (byte)24;
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, 2064, (ObjectCodec) null, (OutputStream) null, byteArray0, 2064, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(2064, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(2064, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)124, (byte)125, (byte) (-113), (byte)17, (byte)24}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
Object object0 = uTF8JsonGenerator0.getOutputTarget();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNull(object0);
IOContext iOContext3 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext3);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)24, bigInteger0.byteValue());
assertEquals((short)4376, bigInteger0.shortValue());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)124, (byte)125, (byte) (-113), (byte)17, (byte)24}, byteArray0);
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((byte)24, bigInteger0.byteValue());
assertEquals((short)4376, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)124, (byte)125, (byte) (-113), (byte)17, (byte)24}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeNumber(bigInteger0);
// 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 test122() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
int int0 = 739;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 739, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "e/o=,L$?3bi";
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(25, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeBoolean(true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(30, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString1 = new SerializedString("K8xkDiM=QRKi");
assertEquals("K8xkDiM=QRKi", serializedString1.toString());
assertEquals("K8xkDiM=QRKi", serializedString1.getValue());
assertEquals(12, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null);
assertNotNull(pushbackInputStream0);
// try {
uTF8JsonGenerator0.writeBinary((InputStream) pushbackInputStream0, (-3326));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.PushbackInputStream", e);
// }
}
@Test(timeout = 4000)
public void test123() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
mockPrintStream0.flush();
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertNotSame(mockPrintStream0, mockPrintStream1);
char[] charArray0 = new char[1];
charArray0[0] = '!';
uTF8JsonGenerator0.writeString(charArray0, 935, (-126));
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertEquals(1, charArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertArrayEquals(new char[] {'!'}, charArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((Base64Variant) null, byteArray0, 2, 3340);
// 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 test124() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeStartArray();
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
byte[] byteArray1 = serializedString0.asUnquotedUTF8();
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(1, byteArray1.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray1);
assertNotSame(byteArray1, byteArray0);
assertNotNull(byteArray1);
char[] charArray0 = new char[4];
charArray0[0] = 'y';
charArray0[1] = '|';
charArray0[2] = '|';
charArray0[3] = '{';
uTF8JsonGenerator0.writeString(charArray0, 100, (-2783));
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(2L, file0.length());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(1, byteArray0.length);
assertEquals(4, charArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertArrayEquals(new char[] {'y', '|', '|', '{'}, charArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
MockPrintStream mockPrintStream2 = new MockPrintStream("wu");
assertFalse(mockPrintStream2.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream2.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream2);
UTF8JsonGenerator uTF8JsonGenerator1 = null;
// try {
uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 3037, (ObjectCodec) null, byteArrayBuilder0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test125() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = null;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
PrintStream printStream1 = mockPrintStream1.append((CharSequence) null, 0, 1);
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertFalse(printStream1.equals((Object)printStream0));
assertFalse(printStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotSame(printStream1, printStream0);
assertSame(printStream1, mockPrintStream1);
assertNotSame(printStream1, mockPrintStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(mockPrintStream1, printStream1);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotNull(printStream1);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(printStream0, printStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
uTF8JsonGenerator1.writeFieldName("");
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canWrite());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(iOContext1, iOContext0);
assertSame(mockPrintStream1, printStream1);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
uTF8JsonGenerator0.writeNumber((double) 56319);
}
@Test(timeout = 4000)
public void test126() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 739, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(11, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(25, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(30, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString1 = new SerializedString("K8xkDiM=QRKi");
assertEquals(12, serializedString1.charLength());
assertEquals("K8xkDiM=QRKi", serializedString1.getValue());
assertEquals("K8xkDiM=QRKi", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null, 1560);
assertNotNull(pushbackInputStream0);
int int0 = 1670;
int int1 = uTF8JsonGenerator0.writeBinary((InputStream) pushbackInputStream0, 0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(33, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(739, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(int1 == int0);
assertEquals(0, int1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test127() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" i a commen", "");
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp");
boolean boolean0 = FileSystemHandling.appendDataToFile(evoSuiteFile0, byteArray0);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertFalse(boolean0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " i a commen", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
PrintStream printStream1 = mockPrintStream1.append((CharSequence) null, 0, 1);
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(1L, file0.length());
assertFalse(printStream1.equals((Object)printStream0));
assertFalse(printStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertSame(printStream1, mockPrintStream1);
assertNotSame(printStream1, printStream0);
assertNotSame(printStream1, mockPrintStream0);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream1, printStream1);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotNull(printStream1);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(1L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(1L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(8000);
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(2L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 3, 55296);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(4L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.flush();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals("/tmp/ i a commen0", file0.toString());
assertTrue(file0.isFile());
assertEquals(" i a commen0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(5L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, printStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber(943);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.io.NumberOutput", e);
// }
}
@Test(timeout = 4000)
public void test128() throws Throwable {
String string0 = "";
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
boolean boolean0 = true;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeStartArray();
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeArray((int[]) null, 2, 114);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test129() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 943, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(943, uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[6];
charArray0[0] = '_';
charArray0[2] = 'r';
charArray0[3] = 'y';
charArray0[4] = 'y';
charArray0[5] = 'Q';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 0, 943);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 6
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test130() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
TokenFilter tokenFilter1 = tokenFilter0.filterStartArray();
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertTrue(tokenFilter1.includeBinary());
assertTrue(tokenFilter1.includeRawValue());
assertTrue(tokenFilter1.includeNull());
assertSame(tokenFilter0, tokenFilter1);
assertSame(tokenFilter1, tokenFilter0);
assertNotNull(tokenFilter1);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
IOContext iOContext2 = new IOContext(bufferRecycler0, tokenFilter0, true);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
uTF8JsonGenerator0.writeBoolean(false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBinary((Base64Variant) null, byteArrayBuilder0.NO_BYTES, 2, 0);
// 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 test131() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[9];
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8, (ObjectCodec) null, (OutputStream) null, byteArray0, 8, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(8, uTF8JsonGenerator1.getFeatureMask());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeFieldName("e/o=,L$?3bi");
// 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 test132() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1._writePPFieldName("e/o=,L$?3bi");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(12, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(1, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(12, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3233));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeNumber((short)4763);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeStartObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator2.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator2.getOutputBuffered());
assertEquals(57343, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator2);
// Undeclared exception!
// try {
uTF8JsonGenerator2.writeUTF8String(byteArrayBuilder0.NO_BYTES, 3, 57343);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 3
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test133() throws Throwable {
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "W$UELLy|h~1%=");
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
SerializedString serializedString0 = new SerializedString("b6");
assertEquals(2, serializedString0.charLength());
assertEquals("b6", serializedString0.toString());
assertEquals("b6", serializedString0.getValue());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asQuotedUTF8();
assertEquals(2, serializedString0.charLength());
assertEquals("b6", serializedString0.toString());
assertEquals("b6", serializedString0.getValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)98, (byte)54}, byteArray0);
assertNotNull(byteArray0);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 97, (ObjectCodec) null, (OutputStream) null, byteArray0, (-2), false);
assertEquals(2, serializedString0.charLength());
assertEquals("b6", serializedString0.toString());
assertEquals("b6", serializedString0.getValue());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(97, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-2), uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)98, (byte)54}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw("Decimal point not followed by a digit");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -2
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test134() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "9B5, ^Nm");
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "e/o=,L$?3bi";
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
int[] intArray0 = new int[3];
intArray0[0] = 1;
intArray0[1] = 1;
intArray0[2] = 2;
uTF8JsonGenerator0.writeArray(intArray0, 1631, 0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(3, intArray0.length);
assertArrayEquals(new int[] {1, 1, 2}, intArray0);
assertNotSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._verifyPrettyValueWrite("", 1);
// 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 test135() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler1);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertEquals(200, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)3;
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)35;
byteArray0[3] = (byte) (-26);
byteArray0[4] = (byte)41;
byteArray0[5] = (byte)15;
byteArray0[6] = (byte)21;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, byteArrayOutputStream0, byteArray0, (byte)41, true);
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(41, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertEquals(7, byteArray0.length);
assertArrayEquals(new byte[] {(byte)3, (byte)83, (byte)35, (byte) (-26), (byte)41, (byte)15, (byte)21}, byteArray0);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString(";24X");
assertEquals(4, serializedString0.charLength());
assertEquals(";24X", serializedString0.getValue());
assertEquals(";24X", serializedString0.toString());
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ByteArrayOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test136() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
uTF8JsonGenerator1.writeArrayFieldStart("e/o=,L$?3bi");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(28, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(28, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator1.writeNumber((short)44);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(31, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(31, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator1.writeStartObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(34, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(34, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRaw('y');
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator2 = null;
// try {
uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext0, 51, (ObjectCodec) null, (OutputStream) null);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test137() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(textBuffer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals(11, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
uTF8JsonGenerator0._outputTail = 35;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(48, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals(11, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[10];
SerializedString serializedString2 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString1));
assertTrue(serializedString2.equals((Object)serializedString0));
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeString((SerializableString) serializedString2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(62, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString1));
assertTrue(serializedString2.equals((Object)serializedString0));
assertNotSame(serializedString2, serializedString1);
assertNotSame(serializedString2, serializedString0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(71, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(10, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(83, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertTrue(serializedString0.equals((Object)serializedString1));
assertTrue(serializedString0.equals((Object)serializedString2));
assertNotSame(serializedString0, serializedString2);
assertNotSame(serializedString0, serializedString1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(86, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = new BigDecimal((double) 3);
assertEquals((short)3, bigDecimal0.shortValue());
assertEquals((byte)3, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((short)3, bigDecimal0.shortValue());
assertEquals((byte)3, bigDecimal0.byteValue());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(88, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0._releaseBuffers();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(88, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeStartArray();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// }
}
@Test(timeout = 4000)
public void test138() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
TokenFilter tokenFilter1 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter1.includeBinary());
assertTrue(tokenFilter1.includeNull());
assertTrue(tokenFilter1.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertSame(tokenFilter1, tokenFilter0);
assertNotNull(tokenFilter1);
MockPrintStream mockPrintStream0 = new MockPrintStream("Bz_T)B#dHz37X");
assertNotNull(mockPrintStream0);
PrintStream printStream0 = mockPrintStream0.append((CharSequence) "Bz_T)B#dHz37X");
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, printStream0, byteArrayBuilder0.NO_BYTES, 57343, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(57343, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
char[] charArray0 = iOContext0.allocTokenBuffer(1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(4000, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(charArray0);
IOContext iOContext2 = new IOContext(bufferRecycler0, tokenFilter0, true);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext2, 464, (ObjectCodec) null, printStream0);
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(0, uTF8JsonGenerator2.getOutputBuffered());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator2.getHighestEscapedChar());
assertEquals(464, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.isClosed());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator2);
PrintStream printStream1 = mockPrintStream0.append(']');
assertSame(mockPrintStream0, printStream0);
assertSame(mockPrintStream0, printStream1);
assertSame(printStream1, mockPrintStream0);
assertSame(printStream1, printStream0);
assertNotNull(printStream1);
printStream0.println(0.0);
assertSame(mockPrintStream0, printStream0);
assertSame(mockPrintStream0, printStream1);
assertSame(printStream0, printStream1);
assertSame(printStream0, mockPrintStream0);
uTF8JsonGenerator2.writeRaw(charArray0, 57343, (-112));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(0, uTF8JsonGenerator2.getOutputBuffered());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator2.getHighestEscapedChar());
assertEquals(464, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertEquals(4000, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(tokenFilter0, tokenFilter1);
assertSame(mockPrintStream0, printStream0);
assertSame(mockPrintStream0, printStream1);
assertSame(printStream0, printStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(uTF8JsonGenerator2, uTF8JsonGenerator0);
assertNotSame(uTF8JsonGenerator2, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
BigDecimal bigDecimal0 = new BigDecimal((double) 57343);
assertEquals((byte) (-1), bigDecimal0.byteValue());
assertEquals((short) (-8193), bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((byte) (-1), bigDecimal0.byteValue());
assertEquals((short) (-8193), bigDecimal0.shortValue());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator1._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeRawValue((SerializableString) serializedString0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test139() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "u");
assertEquals(" in a comment0u", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0u", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("u", objectArray0);
assertEquals(" in a comment0u", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0u", file0.toString());
assertTrue(file0.canExecute());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0u", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0u", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[0];
printStream0.print(charArray0);
assertEquals(" in a comment0u", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0u", file0.toString());
assertTrue(file0.canExecute());
assertEquals(2, objectArray0.length);
assertEquals(0, charArray0.length);
assertArrayEquals(new char[] {}, charArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
BigDecimal bigDecimal0 = BigDecimal.ONE;
assertEquals((short)1, bigDecimal0.shortValue());
assertEquals((byte)1, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0u", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0u", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals((short)1, bigDecimal0.shortValue());
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)6;
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)3;
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 2, 1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0u", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0u", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, objectArray0.length);
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)6, (byte)0, (byte)3}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName("u");
// 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 test140() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
ObjectCodec objectCodec0 = null;
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[7];
byteArray0[1] = (byte)83;
byteArray0[3] = (byte) (-115);
IOContext iOContext2 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext3);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF16_LE;
IOContext iOContext4 = iOContext3.withEncoding(jsonEncoding2);
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext4.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext4.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext4.equals((Object)iOContext1));
assertFalse(iOContext4.equals((Object)iOContext0));
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext4);
assertSame(iOContext3, iOContext2);
assertNotSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(iOContext4, iOContext3);
assertNotSame(iOContext4, iOContext1);
assertNotSame(iOContext4, iOContext0);
assertSame(iOContext4, iOContext2);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext4);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext4, 2, (ObjectCodec) null, pipedOutputStream0, byteArray0, (-2460), false);
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext4.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext4.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-2460), uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext4.equals((Object)iOContext1));
assertFalse(iOContext4.equals((Object)iOContext0));
assertEquals(7, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)83, (byte)0, (byte) (-115), (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test141() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
char[] charArray0 = new char[5];
charArray0[0] = '.';
charArray0[2] = 'o';
charArray0[2] = 'o';
charArray0[4] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 3, 0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'.', '\u0000', 'o', '\u0000', 'o'}, charArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeNumber((short)127);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-111);
byteArray0[1] = (byte)42;
byteArray0[2] = (byte) (-24);
byteArray0[3] = (byte)42;
byteArray0[4] = (byte)63;
byteArray0[5] = (byte)61;
byteArray0[6] = (byte)28;
byteArray0[7] = (byte)114;
uTF8JsonGenerator0.writeBinary(byteArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(26, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(8, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-111), (byte)42, (byte) (-24), (byte)42, (byte)63, (byte)61, (byte)28, (byte)114}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeStartArray();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(28, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 14);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
byte[] byteArray1 = serializedString0.asUnquotedUTF8();
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(1, byteArray1.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray1);
assertNotSame(byteArray1, byteArray0);
assertNotNull(byteArray1);
SerializedString serializedString1 = new SerializedString("Split surrogate on writeRaw() input (last character): first character 0x%4x");
assertEquals("Split surrogate on writeRaw() input (last character): first character 0x%4x", serializedString1.getValue());
assertEquals(75, serializedString1.charLength());
assertEquals("Split surrogate on writeRaw() input (last character): first character 0x%4x", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(31, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertNotSame(serializedString0, serializedString1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
UTF8JsonGenerator uTF8JsonGenerator1 = null;
// try {
uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 56320, (ObjectCodec) null, byteArrayBuilder0, byteArray1, 5, false);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test142() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "#");
assertTrue(file0.canExecute());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertFalse(file0.isHidden());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte byte0 = (byte) (-1);
byte[] byteArray0 = new byte[4];
byteArray0[0] = (byte) (-1);
byteArray0[1] = (byte)31;
byteArray0[2] = (byte)111;
byteArray0[3] = (byte)31;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 834, (ObjectCodec) null, mockPrintStream0, byteArray0, (byte)31, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertFalse(file0.isHidden());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(31, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(834, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(4, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-1), (byte)31, (byte)111, (byte)31}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(4, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-1), (byte)31, (byte)111, (byte)31}, byteArray0);
assertNotNull(serializedString0);
char[] charArray0 = iOContext0.allocTokenBuffer(63);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray0.length);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canExecute());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(4L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertFalse(file0.isHidden());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(834, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(4, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34, (byte)32, (byte)34, (byte)31}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((-3177L));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 4
// //
// verifyException("com.fasterxml.jackson.core.io.NumberOutput", e);
// }
}
@Test(timeout = 4000)
public void test143() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertTrue(file0.canExecute());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
PrintStream printStream1 = mockPrintStream1.append((CharSequence) null, 0, 1);
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(printStream1.equals((Object)mockPrintStream0));
assertFalse(printStream1.equals((Object)printStream0));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotSame(printStream1, mockPrintStream0);
assertNotSame(printStream1, printStream0);
assertSame(printStream1, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertSame(mockPrintStream1, printStream1);
assertNotNull(printStream1);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals(1L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(8000);
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertEquals(2L, file0.length());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 3, 55296);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(4L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.flush();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(5L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)printStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(mockPrintStream0, printStream1);
assertNotSame(printStream0, printStream1);
assertNotSame(printStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber(943);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.io.NumberOutput", e);
// }
}
@Test(timeout = 4000)
public void test144() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = null;
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[5];
charArray0[0] = '.';
charArray0[2] = '.';
charArray0[2] = '.';
charArray0[4] = '.';
uTF8JsonGenerator0.writeString(charArray0, 3, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'.', '\u0000', '.', '\u0000', '.'}, charArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((short)127);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
int int0 = 3511;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 2, 3511);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 5
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test145() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, pipedOutputStream0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.disable(jsonGenerator_Feature0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
uTF8JsonGenerator1.writeString((char[]) null, 1, (-3));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeBoolean(false);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeFieldName("b 6oC]Ens-");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test146() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-4044), (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[16];
charArray0[0] = '<';
charArray0[1] = ']';
charArray0[2] = ']';
charArray0[3] = '<';
charArray0[4] = ']';
charArray0[5] = '|';
uTF8JsonGenerator0.writeRaw(charArray0, 38, (-2736));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(16, charArray0.length);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigDecimal bigDecimal0 = BigDecimal.ONE;
assertEquals((short)1, bigDecimal0.shortValue());
assertEquals((byte)1, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber((double) (-3091));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(9, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeString(charArray0, 192, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(12, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(16, charArray0.length);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
}
@Test(timeout = 4000)
public void test147() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(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);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 126, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2831, false);
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2831, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(filteringGeneratorDelegate0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.setEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(8000);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.close();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(3L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(3L, file0.length());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator2.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(1, uTF8JsonGenerator2.getFeatureMask());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator2);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator1._rootValueSeparator;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(6L, file0.length());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2831, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator2));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(serializedString1, serializedString0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
uTF8JsonGenerator1.writeNumber(0.0F);
}
@Test(timeout = 4000)
public void test148() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)1;
uTF8JsonGenerator0.writeNumber((-653.539795594));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(28, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char[] charArray0 = new char[5];
charArray0[0] = 'e';
charArray0[2] = 'e';
charArray0[3] = 'e';
charArray0[4] = 'd';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 943, 1521);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 943
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test149() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext1.withEncoding(jsonEncoding1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext3);
boolean boolean0 = true;
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[0];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext2, 15, (ObjectCodec) null, byteArrayOutputStream0, byteArray0, (byte)111, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(15, uTF8JsonGenerator0.getFeatureMask());
assertEquals(111, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = iOContext0.allocTokenBuffer(56319);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext2));
assertEquals(56319, charArray0.length);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 49, (ObjectCodec) null, byteArrayOutputStream0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(49, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeFieldName("f<If");
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.ByteArrayOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test150() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", " in a comment");
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[5];
iOContext1.setEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
byteArray0[0] = (byte) (-1);
byteArray0[1] = (byte)45;
byteArray0[2] = (byte)111;
byteArray0[3] = (byte)4;
byteArray0[4] = (byte)31;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 1, (ObjectCodec) null, mockPrintStream0, byteArray0, (byte)4, true);
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-1), (byte)45, (byte)111, (byte)4, (byte)31}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-1), (byte)45, (byte)111, (byte)4, (byte)31}, byteArray0);
assertNotNull(serializedString0);
char[] charArray0 = iOContext0.allocTokenBuffer(49);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(5L, file0.length());
assertTrue(file0.canExecute());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32, (byte)34, (byte)111, (byte)4, (byte)34}, byteArray0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((long) 0);
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(8L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48, (byte)34, (byte)32, (byte)4, (byte)34}, byteArray0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, (-1230), 2);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test151() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 943, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertEquals(943, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 8);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeNumber((short)44);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(943, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertEquals(943, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 49, (ObjectCodec) null, byteArrayBuilder0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(49, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1.writeRaw('N');
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(49, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
UTF8JsonGenerator uTF8JsonGenerator2 = null;
// try {
uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext0, 3199, (ObjectCodec) null, mockPrintStream0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test152() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 2);
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals((-1), int0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (byte)83, (ObjectCodec) null, mockPrintStream0, byteArray0, 143, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(143, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
Version version0 = uTF8JsonGenerator0.version();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertEquals(143, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(version0.isSnapshot());
assertEquals(2, version0.getMajorVersion());
assertEquals(7, version0.getMinorVersion());
assertEquals("jackson-core", version0.getArtifactId());
assertEquals(7, version0.getPatchLevel());
assertFalse(version0.isUnknownVersion());
assertFalse(version0.isUknownVersion());
assertEquals("com.fasterxml.jackson.core", version0.getGroupId());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(version0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(3L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(serializedString1, serializedString0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber(4);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertEquals(5L, file0.length());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)52}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((long) 3);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertEquals(7L, file0.length());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)51}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, (byte)71, (byte)71);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test153() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.size());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(textBuffer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
uTF8JsonGenerator0._outputTail = 35;
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(48, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[10];
SerializedString serializedString2 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString0));
assertTrue(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeString((SerializableString) serializedString2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(62, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString0));
assertTrue(serializedString2.equals((Object)serializedString1));
assertNotSame(serializedString2, serializedString0);
assertNotSame(serializedString2, serializedString1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(71, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(10, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString3 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString3.getValue());
assertEquals(" ", serializedString3.toString());
assertEquals(1, serializedString3.charLength());
assertFalse(serializedString3.equals((Object)serializedString2));
assertFalse(serializedString3.equals((Object)serializedString0));
assertFalse(serializedString3.equals((Object)serializedString1));
assertNotSame(serializedString3, serializedString2);
assertNotSame(serializedString3, serializedString0);
assertNotSame(serializedString3, serializedString1);
assertNotNull(serializedString3);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
String string0 = "y2G\"z$QaGS";
uTF8JsonGenerator0._verifyPrettyValueWrite("y2G\"z$QaGS", 0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(71, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)18;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 2, 1665);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test154() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
mockPrintStream0.flush();
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertNotSame(mockPrintStream0, mockPrintStream1);
char[] charArray0 = new char[1];
charArray0[0] = '!';
uTF8JsonGenerator0.writeString(charArray0, 935, (-126));
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertEquals(1, charArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertArrayEquals(new char[] {'!'}, charArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber(1);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertTrue(file0.isAbsolute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)49}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test155() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(textBuffer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
uTF8JsonGenerator0._outputTail = 35;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertEquals(48, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[10];
SerializedString serializedString2 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString0));
assertTrue(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeString((SerializableString) serializedString2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(62, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString0));
assertTrue(serializedString2.equals((Object)serializedString1));
assertNotSame(serializedString2, serializedString0);
assertNotSame(serializedString2, serializedString1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(71, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(10, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString3 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString3.getValue());
assertEquals(1, serializedString3.charLength());
assertEquals(" ", serializedString3.toString());
assertFalse(serializedString3.equals((Object)serializedString0));
assertFalse(serializedString3.equals((Object)serializedString1));
assertFalse(serializedString3.equals((Object)serializedString2));
assertNotSame(serializedString3, serializedString0);
assertNotSame(serializedString3, serializedString1);
assertNotSame(serializedString3, serializedString2);
assertNotNull(serializedString3);
SerializedString serializedString4 = new SerializedString("");
assertEquals("", serializedString4.toString());
assertEquals("", serializedString4.getValue());
assertEquals(0, serializedString4.charLength());
assertFalse(serializedString4.equals((Object)serializedString3));
assertFalse(serializedString4.equals((Object)serializedString1));
assertFalse(serializedString4.equals((Object)serializedString0));
assertFalse(serializedString4.equals((Object)serializedString2));
assertNotNull(serializedString4);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString4);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(72, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("", serializedString4.toString());
assertEquals("", serializedString4.getValue());
assertEquals(0, serializedString4.charLength());
assertFalse(serializedString4.equals((Object)serializedString3));
assertFalse(serializedString4.equals((Object)serializedString1));
assertFalse(serializedString4.equals((Object)serializedString0));
assertFalse(serializedString4.equals((Object)serializedString2));
assertNotSame(serializedString4, serializedString3);
assertNotSame(serializedString4, serializedString1);
assertNotSame(serializedString4, serializedString0);
assertNotSame(serializedString4, serializedString2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((-304));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(77, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertEquals(79, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((short) (-2203));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(85, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString4);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(85, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("", serializedString4.toString());
assertEquals("", serializedString4.getValue());
assertEquals(0, serializedString4.charLength());
assertFalse(serializedString4.equals((Object)serializedString3));
assertFalse(serializedString4.equals((Object)serializedString1));
assertFalse(serializedString4.equals((Object)serializedString0));
assertFalse(serializedString4.equals((Object)serializedString2));
assertNotSame(serializedString4, serializedString3);
assertNotSame(serializedString4, serializedString1);
assertNotSame(serializedString4, serializedString0);
assertNotSame(serializedString4, serializedString2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// try {
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test156() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
char char0 = 'y';
uTF8JsonGenerator1.writeFieldName("e/o=,L$?3bi");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(26, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(26, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(31, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
SerializedString serializedString1 = null;
// try {
serializedString1 = new SerializedString((String) null);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Null String illegal for SerializedString
// //
// verifyException("com.fasterxml.jackson.core.io.SerializedString", e);
// }
}
@Test(timeout = 4000)
public void test157() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "e/o=,L$?3bi";
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[2];
byte byte0 = (byte)1;
byteArray0[0] = (byte)1;
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, (-128), (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
char char0 = 'y';
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeNumber((short)114);
// 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 test158() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
double double0 = bigInteger0.doubleValue();
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0.0, double0, 0.01);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(15, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec1 = filteringGeneratorDelegate0.getCodec();
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(15, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(objectCodec1);
filteringGeneratorDelegate0.writeStartArray(2);
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(17, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
boolean boolean0 = false;
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext2, 116, (ObjectCodec) null, (OutputStream) null, byteArrayBuilder0.NO_BYTES, 684, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.isClosed());
assertEquals(116, uTF8JsonGenerator2.getFeatureMask());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertEquals(684, uTF8JsonGenerator2.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator2);
// Undeclared exception!
// try {
uTF8JsonGenerator2.writeFieldName("e/o=,L$?3bi");
// 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 test159() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
File file0 = MockFile.createTempFile(" in a comment", " in a comment");
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", true);
assertTrue(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);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[5];
iOContext1.setEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
byteArray0[0] = (byte) (-1);
byteArray0[1] = (byte)45;
byteArray0[2] = (byte)111;
byteArray0[3] = (byte)4;
byteArray0[4] = (byte)31;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 1, (ObjectCodec) null, mockPrintStream0, byteArray0, (byte)4, true);
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-1), (byte)45, (byte)111, (byte)4, (byte)31}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-1), (byte)45, (byte)111, (byte)4, (byte)31}, byteArray0);
assertNotNull(serializedString0);
char[] charArray0 = iOContext0.allocTokenBuffer(49);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(charArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(" in a comment0 in a comment", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals(5L, file0.length());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0 in a comment", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32, (byte)34, (byte)111, (byte)4, (byte)34}, byteArray0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
uTF8JsonGenerator0.writeUTF8String(byteArray0, (byte)4, 1);
}
@Test(timeout = 4000)
public void test160() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-4044), (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
int int0 = (-2736);
int int1 = (-3091);
char[] charArray0 = new char[16];
uTF8JsonGenerator0.writeFieldName("Q<");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
charArray0[0] = '<';
charArray0[1] = '}';
charArray0[2] = ']';
charArray0[3] = '|';
charArray0[4] = ']';
charArray0[5] = '|';
uTF8JsonGenerator0.writeRaw(charArray0, 38, (-2736));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(16, charArray0.length);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigDecimal bigDecimal0 = new BigDecimal((double) (-3091));
assertEquals((short) (-3091), bigDecimal0.shortValue());
assertEquals((byte) (-19), bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
BigDecimal bigDecimal1 = BigDecimal.valueOf((long) 56319, 58);
assertEquals((byte)0, bigDecimal1.byteValue());
assertEquals((short)0, bigDecimal1.shortValue());
assertFalse(bigDecimal1.equals((Object)bigDecimal0));
assertNotSame(bigDecimal1, bigDecimal0);
assertNotNull(bigDecimal1);
BigDecimal bigDecimal2 = bigDecimal0.max(bigDecimal1);
assertEquals((short) (-3091), bigDecimal0.shortValue());
assertEquals((byte) (-19), bigDecimal0.byteValue());
assertEquals((byte)0, bigDecimal1.byteValue());
assertEquals((short)0, bigDecimal1.shortValue());
assertEquals((short)0, bigDecimal2.shortValue());
assertEquals((byte)0, bigDecimal2.byteValue());
assertFalse(bigDecimal0.equals((Object)bigDecimal1));
assertFalse(bigDecimal1.equals((Object)bigDecimal0));
assertFalse(bigDecimal2.equals((Object)bigDecimal0));
assertNotSame(bigDecimal0, bigDecimal1);
assertNotSame(bigDecimal0, bigDecimal2);
assertNotSame(bigDecimal1, bigDecimal0);
assertSame(bigDecimal1, bigDecimal2);
assertSame(bigDecimal2, bigDecimal1);
assertNotSame(bigDecimal2, bigDecimal0);
assertNotNull(bigDecimal2);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((short) (-3091), bigDecimal0.shortValue());
assertEquals((byte) (-19), bigDecimal0.byteValue());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.length());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(9, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(bigDecimal0.equals((Object)bigDecimal1));
assertFalse(bigDecimal0.equals((Object)bigDecimal2));
assertNotSame(bigDecimal0, bigDecimal1);
assertNotSame(bigDecimal0, bigDecimal2);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// try {
uTF8JsonGenerator0.writeFieldName(" in a comment");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test161() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(24, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, (-128), (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)1, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
int int0 = (-944);
char[] charArray0 = new char[2];
charArray0[0] = 'e';
charArray0[1] = 'd';
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeNumber((double) (byte)1);
// 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 test162() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext1);
char char0 = 'y';
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeArrayFieldStart((String) null);
// 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 test163() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[2];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
IOContext iOContext1 = new IOContext(bufferRecycler0, mockPrintStream1, false);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter1 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter1.includeNull());
assertTrue(tokenFilter1.includeRawValue());
assertTrue(tokenFilter1.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertSame(tokenFilter1, tokenFilter0);
assertNotNull(tokenFilter1);
// Undeclared exception!
// try {
uTF8JsonGenerator0._releaseBuffers();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test164() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char[] charArray0 = new char[5];
charArray0[0] = '.';
charArray0[2] = 'o';
charArray0[2] = 'o';
charArray0[4] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 3, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'.', '\u0000', 'o', '\u0000', 'o'}, charArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeNumber((short)127);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeStartArray();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 14);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray0);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeFieldName("write a number");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(27, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeBoolean(false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(32, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString1 = new SerializedString("K8xkDiM=QRKi");
assertEquals(12, serializedString1.charLength());
assertEquals("K8xkDiM=QRKi", serializedString1.toString());
assertEquals("K8xkDiM=QRKi", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
PushbackInputStream pushbackInputStream0 = new PushbackInputStream((InputStream) null, 1027);
assertNotNull(pushbackInputStream0);
// try {
uTF8JsonGenerator0.writeBinary((InputStream) pushbackInputStream0, 1670);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.PushbackInputStream", e);
// }
}
@Test(timeout = 4000)
public void test165() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
byte[] byteArray0 = new byte[9];
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8, (ObjectCodec) null, (OutputStream) null, byteArray0, 8, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(8, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeString((char[]) null, 134, 57343);
// 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 test166() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
double double0 = bigInteger0.doubleValue();
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0.0, double0, 0.01);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(15, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(15, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(17, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeRawUTF8String(byteArrayBuilder0.NO_BYTES, 56320, 116);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test167() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
File file0 = MockFile.createTempFile(" in a comment", "#");
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0#", file0.getName());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0#", file0.getName());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
short short0 = (short) (-1415);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((short) (-1415));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.io.NumberOutput", e);
// }
}
@Test(timeout = 4000)
public void test168() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
char[] charArray0 = iOContext1.allocTokenBuffer(0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 1);
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, int0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 33, (ObjectCodec) null, pipedOutputStream0, byteArray0, 1, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(33, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
byte[] byteArray1 = new byte[4];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)83;
byteArray1[1] = (byte) (-64);
byteArray1[2] = (byte) (-109);
BigDecimal bigDecimal0 = BigDecimal.ONE;
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
int int1 = bigDecimal0.scale();
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertFalse(int1 == int0);
assertEquals(0, int1);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(33, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)34, (byte)49, (byte)34, (byte)0, (byte)0}, byteArray0);
assertSame(iOContext0, iOContext1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeFieldName("");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(33, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)34, (byte)49, (byte)34, (byte)44, (byte)0}, byteArray0);
assertSame(iOContext0, iOContext1);
assertNotSame(byteArray0, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// try {
uTF8JsonGenerator0.writeBoolean(false);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test169() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)126;
byteArray0[3] = (byte) (-115);
byteArray0[1] = (byte)14;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 568, (ObjectCodec) null, pipedOutputStream0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(568, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "})";
uTF8JsonGenerator0.writeBinaryField("})", byteArray0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(568, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(7, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)14, (byte)126, (byte) (-115), (byte)0, (byte)0, (byte)0}, byteArray0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
UTF8JsonGenerator uTF8JsonGenerator1 = null;
// try {
uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, (byte) (-115), (ObjectCodec) null, pipedOutputStream0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test170() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeUTF8String(byteArray0, 1, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(6L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertEquals(10L, file0.length());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test171() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[2];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
IOContext iOContext1 = new IOContext(bufferRecycler0, mockPrintStream1, false);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter1 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter1.includeRawValue());
assertTrue(tokenFilter1.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter1.toString());
assertTrue(tokenFilter1.includeNull());
assertSame(tokenFilter1, tokenFilter0);
assertNotNull(tokenFilter1);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
double double0 = bigInteger0.doubleValue();
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0}, byteArray0);
assertEquals(0.0, double0, 0.01);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48, (byte)0}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(2L, file0.length());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48, (byte)32}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(2L, file0.length());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48, (byte)32}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.canExecute());
assertEquals(4L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)44, (byte)32}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test172() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
uTF8JsonGenerator1.writeNumber((short)44);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(16, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator1.writeStartObject();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(18, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeRaw('y');
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(19, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator2 = null;
// try {
uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext0, 51, (ObjectCodec) null, (OutputStream) null);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test173() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "#");
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0#", file0.getName());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0#", file0.getName());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getFreeSpace());
assertEquals(3L, file0.length());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0#", file0.getName());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeUTF8String(byteArray0, 1, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(6L, file0.length());
assertEquals(0L, file0.getTotalSpace());
assertEquals(" in a comment0#", file0.getName());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// Undeclared exception!
uTF8JsonGenerator0.writeFieldName("#");
}
@Test(timeout = 4000)
public void test174() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
double double0 = bigInteger0.doubleValue();
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0.0, double0, 0.01);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator1.writeRaw("start an array");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(29, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(29, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber("e/o=,L$?3bi");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(41, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator1.writeNumber((-393.0F));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(48, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertEquals(48, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test175() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 15);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator1.writeRaw('g');
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)103}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
uTF8JsonGenerator1.writeString(" in a comment");
}
@Test(timeout = 4000)
public void test176() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
String string0 = "#";
File file0 = MockFile.createTempFile(" in a comment", "#");
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertTrue(boolean1 == boolean0);
assertFalse(boolean1);
byte[] byteArray0 = new byte[1];
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, mockPrintStream0, byteArray0, 3, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertTrue(file0.canExecute());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertNotNull(serializedString0);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(charArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals(3L, file0.length());
assertTrue(file0.canExecute());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeUTF8String(byteArray0, 1, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0#", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(" in a comment0#", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertFalse(file0.isDirectory());
assertEquals(6L, file0.length());
assertTrue(file0.canExecute());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((BigDecimal) null);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test177() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char[] charArray0 = new char[5];
charArray0[0] = '.';
charArray0[1] = 'o';
charArray0[2] = 'o';
charArray0[3] = '.';
charArray0[4] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 18, 0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'.', 'o', 'o', '.', 'o'}, charArray0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeNumber((short)127);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeStartArray();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 14);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRaw('g');
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeString("V");
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(19, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// try {
uTF8JsonGenerator0.writeNumber(1.0F);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a number, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test178() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
String string0 = "";
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, objectArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
IOContext iOContext1 = new IOContext(bufferRecycler0, objectArray0[0], false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, objectArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
// Undeclared exception!
// try {
uTF8JsonGenerator0._verifyPrettyValueWrite(" in a comment", 1);
// 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 test179() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
boolean boolean0 = file0.setWritable(false, false);
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertTrue(boolean0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
File file1 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment1", file1.getName());
assertEquals(0L, file1.getUsableSpace());
assertFalse(file1.isHidden());
assertTrue(file1.canWrite());
assertEquals(0L, file1.getFreeSpace());
assertEquals(0L, file1.length());
assertFalse(file1.isDirectory());
assertTrue(file1.isAbsolute());
assertTrue(file1.canExecute());
assertEquals(1392409281320L, file1.lastModified());
assertEquals(0L, file1.getTotalSpace());
assertEquals("/tmp/ in a comment1", file1.toString());
assertTrue(file1.isFile());
assertEquals("/tmp", file1.getParent());
assertTrue(file1.canRead());
assertTrue(file1.exists());
assertFalse(file1.equals((Object)file0));
assertNotSame(file1, file0);
assertNotNull(file1);
boolean boolean1 = file0.renameTo(file1);
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment1", file1.getName());
assertEquals(0L, file1.getUsableSpace());
assertFalse(file1.isHidden());
assertTrue(file1.canWrite());
assertEquals(0L, file1.getFreeSpace());
assertEquals(0L, file1.length());
assertFalse(file1.isDirectory());
assertTrue(file1.isAbsolute());
assertTrue(file1.canExecute());
assertEquals(1392409281320L, file1.lastModified());
assertEquals(0L, file1.getTotalSpace());
assertEquals("/tmp/ in a comment1", file1.toString());
assertTrue(file1.isFile());
assertEquals("/tmp", file1.getParent());
assertTrue(file1.canRead());
assertTrue(file1.exists());
assertFalse(file0.equals((Object)file1));
assertFalse(file1.equals((Object)file0));
assertFalse(boolean1 == boolean0);
assertFalse(boolean1);
assertNotSame(file0, file1);
assertNotSame(file1, file0);
int[] intArray0 = new int[2];
intArray0[0] = (-1195);
intArray0[1] = 78;
uTF8JsonGenerator0._outputEscapes = intArray0;
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
charArray0[6] = '|';
uTF8JsonGenerator0.writeRaw(charArray0, 3, 3);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(file0.equals((Object)file1));
assertEquals(19, charArray0.length);
assertNotSame(file0, file1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
BigDecimal bigDecimal0 = new BigDecimal((double) 2);
assertEquals((byte)2, bigDecimal0.byteValue());
assertEquals((short)2, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((byte)2, bigDecimal0.byteValue());
assertEquals((short)2, bigDecimal0.shortValue());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(file0.equals((Object)file1));
assertNotSame(file0, file1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeFieldName("E#HK");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 69
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test180() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
File file1 = MockFile.createTempFile(" in a comment", "");
assertTrue(file1.isFile());
assertEquals("/tmp", file1.getParent());
assertFalse(file1.isHidden());
assertEquals(0L, file1.getUsableSpace());
assertTrue(file1.canExecute());
assertEquals(0L, file1.getFreeSpace());
assertTrue(file1.canWrite());
assertTrue(file1.isAbsolute());
assertFalse(file1.isDirectory());
assertEquals("/tmp/ in a comment1", file1.toString());
assertEquals(0L, file1.length());
assertEquals(" in a comment1", file1.getName());
assertEquals(0L, file1.getTotalSpace());
assertEquals(1392409281320L, file1.lastModified());
assertTrue(file1.canRead());
assertTrue(file1.exists());
assertFalse(file1.equals((Object)file0));
assertNotSame(file1, file0);
assertNotNull(file1);
boolean boolean0 = file0.renameTo(file1);
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file1.isFile());
assertEquals("/tmp", file1.getParent());
assertFalse(file1.isHidden());
assertEquals(0L, file1.getUsableSpace());
assertTrue(file1.canExecute());
assertEquals(0L, file1.getFreeSpace());
assertTrue(file1.canWrite());
assertTrue(file1.isAbsolute());
assertFalse(file1.isDirectory());
assertEquals("/tmp/ in a comment1", file1.toString());
assertEquals(0L, file1.length());
assertEquals(" in a comment1", file1.getName());
assertEquals(0L, file1.getTotalSpace());
assertEquals(1392409281320L, file1.lastModified());
assertTrue(file1.canRead());
assertTrue(file1.exists());
assertFalse(file0.equals((Object)file1));
assertFalse(file1.equals((Object)file0));
assertFalse(boolean0);
assertNotSame(file0, file1);
assertNotSame(file1, file0);
charArray0[6] = '|';
charArray0[1] = '|';
charArray0[2] = 'z';
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertNotNull(byteArray0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeFieldName((String) null);
// 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 test181() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
String string0 = "e/o=,L$?3bi";
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
byte[] byteArray0 = new byte[0];
int int0 = serializedString0.appendUnquotedUTF8(byteArray0, 1);
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(0, byteArray0.length);
assertArrayEquals(new byte[] {}, byteArray0);
assertEquals((-1), int0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray1 = new byte[2];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)1;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
IOContext iOContext2 = new IOContext(bufferRecycler0, pipedInputStream0, true);
assertEquals(0, pipedInputStream0.available());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext2);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertEquals(0, pipedInputStream0.available());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext3, 3, (ObjectCodec) null, (OutputStream) null, byteArray1, (byte)64, true);
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertEquals(3, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(64, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, pipedInputStream0.available());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertFalse(byteArray1.equals((Object)byteArray0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals(2, byteArray1.length);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeRaw('x');
// 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 test182() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(textBuffer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
char[] charArray0 = new char[5];
charArray0[0] = '0';
charArray0[1] = '\"';
charArray0[2] = '?';
charArray0[3] = '7';
charArray0[4] = '{';
uTF8JsonGenerator0.writeRaw(charArray0, 33, (-128));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'0', '\"', '?', '7', '{'}, charArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
SerializedString serializedString1 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals(11, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
SerializedString serializedString2 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString2.toString());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.getValue());
assertFalse(serializedString2.equals((Object)serializedString1));
assertFalse(serializedString2.equals((Object)serializedString0));
assertNotSame(serializedString2, serializedString1);
assertNotSame(serializedString2, serializedString0);
assertNotNull(serializedString2);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)83;
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)83;
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 3);
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertTrue(serializedString0.equals((Object)serializedString1));
assertFalse(serializedString0.equals((Object)serializedString2));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)83, (byte)83}, byteArray0);
assertEquals((-1), int0);
assertNotSame(serializedString0, serializedString1);
assertNotSame(serializedString0, serializedString2);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 0, (ObjectCodec) null, (OutputStream) null, byteArray0, 2, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFeatureMask());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)83, (byte)83}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString3 = (SerializedString)uTF8JsonGenerator1._rootValueSeparator;
assertEquals(" ", serializedString3.toString());
assertEquals(" ", serializedString3.getValue());
assertEquals(1, serializedString3.charLength());
assertFalse(serializedString3.equals((Object)serializedString1));
assertFalse(serializedString3.equals((Object)serializedString0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)83, (byte)83}, byteArray0);
assertNotSame(serializedString3, serializedString1);
assertSame(serializedString3, serializedString2);
assertNotSame(serializedString3, serializedString0);
assertNotNull(serializedString3);
uTF8JsonGenerator0.writeString((SerializableString) serializedString2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(" ", serializedString2.toString());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.getValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(serializedString2.equals((Object)serializedString1));
assertFalse(serializedString2.equals((Object)serializedString0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(serializedString2, serializedString1);
assertSame(serializedString2, serializedString3);
assertNotSame(serializedString2, serializedString0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext1.setEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeRawUTF8String(byteArray0, 244, 56320);
// 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 test183() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
uTF8JsonGenerator0.writeBinaryField("2<'_z)KkUoYu", byteArrayBuilder0.NO_BYTES);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 5049, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(5049, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1.writeBoolean(true);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(4, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(5049, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
// Undeclared exception!
// try {
iOContext0.allocConcatBuffer();
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test184() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext1, 51, (ObjectCodec) null, (OutputStream) null, byteArrayBuilder0.NO_BYTES, (-2592), true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator2.isClosed());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertEquals(51, uTF8JsonGenerator2.getFeatureMask());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertEquals((-2592), uTF8JsonGenerator2.getOutputBuffered());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(13, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(13, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(89);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals(15, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(127, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertNotSame(iOContext0, iOContext1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.close();
// 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 test185() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext2, 3, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[0];
uTF8JsonGenerator0.writeString(charArray0, 1532, (-993));
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(0, charArray0.length);
assertArrayEquals(new char[] {}, charArray0);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((short)11);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeStartArray();
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(12, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRaw('c');
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString("V");
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayBuilder byteArrayBuilder1 = new ByteArrayBuilder(128);
assertEquals(0, byteArrayBuilder1.getCurrentSegmentLength());
assertFalse(byteArrayBuilder1.equals((Object)byteArrayBuilder0));
assertNotNull(byteArrayBuilder1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext0, 497, (ObjectCodec) null, byteArrayBuilder1, byteArrayBuilder1.NO_BYTES, 0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, byteArrayBuilder1.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(497, uTF8JsonGenerator1.getFeatureMask());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(byteArrayBuilder1.equals((Object)byteArrayBuilder0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeStartObject();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 0
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test186() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(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(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[5];
charArray0[0] = '.';
charArray0[1] = 'o';
charArray0[2] = 'o';
charArray0[3] = '.';
charArray0[4] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 18, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'.', 'o', 'o', '.', 'o'}, charArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((short)127);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeStartArray();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 14);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRaw('g');
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString("V");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeStartObject();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(19, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw((String) null);
// 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 test187() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, "Decimal point not followed by a digit", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(1361);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(1361, charArray0.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("b6");
assertEquals(2, serializedString0.charLength());
assertEquals("b6", serializedString0.toString());
assertEquals("b6", serializedString0.getValue());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asQuotedUTF8();
assertEquals(2, serializedString0.charLength());
assertEquals("b6", serializedString0.toString());
assertEquals("b6", serializedString0.getValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)98, (byte)54}, byteArray0);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, serializedString0.charLength());
assertEquals("b6", serializedString0.toString());
assertEquals("b6", serializedString0.getValue());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, serializedString0.charLength());
assertEquals("b6", serializedString0.toString());
assertEquals("b6", serializedString0.getValue());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((BigDecimal) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// try {
uTF8JsonGenerator0._writePPFieldName("Decimal point not followed by a digit");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test188() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-4044), (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[16];
charArray0[0] = '<';
charArray0[1] = '}';
charArray0[2] = ']';
charArray0[3] = '|';
charArray0[4] = ']';
charArray0[5] = '|';
uTF8JsonGenerator0.writeRaw(charArray0, 38, (-2736));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(16, charArray0.length);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigDecimal bigDecimal0 = new BigDecimal((double) (-3091));
assertEquals((short) (-3091), bigDecimal0.shortValue());
assertEquals((byte) (-19), bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((short) (-3091), bigDecimal0.shortValue());
assertEquals((byte) (-19), bigDecimal0.byteValue());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeFieldName(" in a comment");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(21, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeBoolean(false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(27, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeNumber((-3091));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeRaw("Null String illegal for SerializedString");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(75, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeNumber(" in a comment");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(91, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeNumber((float) (-3091));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(101, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
}
@Test(timeout = 4000)
public void test189() throws Throwable {
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(422);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(422, charArray0.length);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-156), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("0123456789ABCDEF");
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asQuotedUTF8();
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(16, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray1 = new byte[8];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[2] = (byte)1;
byteArray1[3] = (byte)1;
SerializedString serializedString1 = new SerializedString("0123456789ABCDEF");
assertEquals("0123456789ABCDEF", serializedString1.toString());
assertEquals("0123456789ABCDEF", serializedString1.getValue());
assertEquals(16, serializedString1.charLength());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertTrue(serializedString0.equals((Object)serializedString1));
assertNotSame(serializedString0, serializedString1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertNotNull(bigInteger0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
PipedInputStream pipedInputStream0 = new PipedInputStream(pipedOutputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
BufferedInputStream bufferedInputStream0 = new BufferedInputStream(pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(bufferedInputStream0);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferedInputStream0, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, pipedInputStream0.available());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, pipedInputStream0.available());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
boolean boolean1 = bufferedInputStream0.markSupported();
assertEquals(0, pipedInputStream0.available());
assertFalse(boolean1 == boolean0);
assertTrue(boolean1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, (-247), (ObjectCodec) null, (OutputStream) null, byteArray0, (-701), false);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals((-701), uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals((-247), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(0, pipedInputStream0.available());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertTrue(serializedString0.equals((Object)serializedString1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(16, byteArray0.length);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeNumber(bigInteger0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -701
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test190() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-7266), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-7266), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals((-7266), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString2 = new SerializedString("&V|#x9/{[bS");
assertEquals("&V|#x9/{[bS", serializedString2.getValue());
assertEquals(11, serializedString2.charLength());
assertEquals("&V|#x9/{[bS", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals((-7266), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(27, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertFalse(serializedString1.equals((Object)serializedString2));
assertNotSame(serializedString1, serializedString0);
assertNotSame(serializedString1, serializedString2);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char[] charArray0 = new char[5];
charArray0[0] = 'b';
charArray0[1] = 'g';
charArray0[2] = '>';
charArray0[3] = 'i';
byte[] byteArray0 = serializedString1.asUnquotedUTF8();
assertEquals(11, serializedString1.charLength());
assertEquals("e/o=,L$?3bi", serializedString1.getValue());
assertEquals("e/o=,L$?3bi", serializedString1.toString());
assertTrue(serializedString1.equals((Object)serializedString0));
assertFalse(serializedString1.equals((Object)serializedString2));
assertEquals(11, byteArray0.length);
assertNotSame(serializedString1, serializedString0);
assertNotSame(serializedString1, serializedString2);
assertNotNull(byteArray0);
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
charArray0[4] = '\"';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 3, 3);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 5
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test191() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char[] charArray0 = new char[5];
charArray0[0] = '.';
charArray0[1] = 'o';
charArray0[2] = 'o';
charArray0[3] = '.';
charArray0[4] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 18, 0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(5, charArray0.length);
assertArrayEquals(new char[] {'.', 'o', 'o', '.', 'o'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeNumber((short)127);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(11, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeStartArray();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 14);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRaw('g');
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeString("V");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeStartObject();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(19, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// try {
uTF8JsonGenerator0.writeString("0123456789ABCDEF");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a string, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test192() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(2, objectArray0.length);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
File file1 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file1.getTotalSpace());
assertEquals(1392409281320L, file1.lastModified());
assertEquals(0L, file1.length());
assertTrue(file1.exists());
assertEquals("/tmp/ in a comment1", file1.toString());
assertEquals(0L, file1.getFreeSpace());
assertFalse(file1.isDirectory());
assertTrue(file1.canExecute());
assertTrue(file1.canRead());
assertEquals(" in a comment1", file1.getName());
assertTrue(file1.isFile());
assertTrue(file1.canWrite());
assertTrue(file1.isAbsolute());
assertEquals("/tmp", file1.getParent());
assertFalse(file1.isHidden());
assertEquals(0L, file1.getUsableSpace());
assertFalse(file1.equals((Object)file0));
assertNotSame(file1, file0);
assertNotNull(file1);
boolean boolean0 = file0.renameTo(file1);
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file1.getTotalSpace());
assertEquals(1392409281320L, file1.lastModified());
assertEquals(0L, file1.length());
assertTrue(file1.exists());
assertEquals("/tmp/ in a comment1", file1.toString());
assertEquals(0L, file1.getFreeSpace());
assertFalse(file1.isDirectory());
assertTrue(file1.canExecute());
assertTrue(file1.canRead());
assertEquals(" in a comment1", file1.getName());
assertTrue(file1.isFile());
assertTrue(file1.canWrite());
assertTrue(file1.isAbsolute());
assertEquals("/tmp", file1.getParent());
assertFalse(file1.isHidden());
assertEquals(0L, file1.getUsableSpace());
assertFalse(file0.equals((Object)file1));
assertFalse(file1.equals((Object)file0));
assertFalse(boolean0);
assertNotSame(file0, file1);
assertNotSame(file1, file0);
charArray0[6] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-2736), (-3070));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(file0.equals((Object)file1));
assertEquals(2, objectArray0.length);
assertEquals(19, charArray0.length);
assertNotSame(file0, file1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = BigDecimal.ONE;
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(file0.equals((Object)file1));
assertEquals(2, objectArray0.length);
assertNotSame(file0, file1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName("E{\"e<D%!)w[");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(file0.equals((Object)file1));
assertEquals(2, objectArray0.length);
assertNotSame(file0, file1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(file0.equals((Object)file1));
assertEquals(2, objectArray0.length);
assertNotSame(file0, file1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
int int0 = uTF8JsonGenerator0.getOutputBuffered();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(file0.equals((Object)file1));
assertEquals(2, objectArray0.length);
assertEquals(20, int0);
assertNotSame(file0, file1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((-9223372036854775808L));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(41, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(file0.equals((Object)file1));
assertEquals(2, objectArray0.length);
assertNotSame(file0, file1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test193() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
uTF8JsonGenerator0.writeFieldName("?Ka~0:G1zB}7b-");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(28, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
IOContext iOContext2 = new IOContext(bufferRecycler0, "", true);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext2);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext3);
int int0 = (-530);
byte[] byteArray1 = new byte[4];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)1;
byteArray1[1] = (byte)1;
byteArray1[2] = (byte)1;
byteArray1[3] = (byte)1;
// try {
uTF8JsonGenerator0.writeBinaryField("?Ka~0:G1zB}7b-", byteArray1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test194() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", 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/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-4044), (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", 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/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[6];
charArray0[0] = '<';
charArray0[1] = 'z';
charArray0[2] = ']';
charArray0[3] = '|';
charArray0[4] = ']';
charArray0[5] = '|';
uTF8JsonGenerator0.writeRaw(charArray0, 38, (-2736));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", 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/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(6, charArray0.length);
assertArrayEquals(new char[] {'<', 'z', ']', '|', ']', '|'}, charArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = new BigDecimal((double) (-3070));
assertEquals((short) (-3070), bigDecimal0.shortValue());
assertEquals((byte)2, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", 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/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((short) (-3070), bigDecimal0.shortValue());
assertEquals((byte)2, bigDecimal0.byteValue());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName(" in a comment");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", 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/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(21, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", 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/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(27, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((-3070));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals(" in a comment0", 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/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-4044), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test195() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNull(objectCodec0);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator1._verifyValueWrite((String) null);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.isFile());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test196() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
SerializedString serializedString0 = new SerializedString(":B");
assertEquals(":B", serializedString0.getValue());
assertEquals(2, serializedString0.charLength());
assertEquals(":B", serializedString0.toString());
assertNotNull(serializedString0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2047, (ObjectCodec) null, pipedOutputStream0, byteArray0, 0, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2047, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(":B", serializedString0.getValue());
assertEquals(2, serializedString0.charLength());
assertEquals(":B", serializedString0.toString());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2047, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34, (byte)58, (byte)66, (byte)34, (byte)0, (byte)0}, byteArray0);
assertSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
IOContext iOContext2 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, 3, (ObjectCodec) null, pipedOutputStream0, byteArray0, 400, true);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(400, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(3, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34, (byte)58, (byte)66, (byte)34, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
char[] charArray0 = new char[8];
charArray0[0] = 'd';
charArray0[1] = 'e';
charArray0[2] = 'e';
charArray0[3] = 'd';
charArray0[4] = 'e';
charArray0[5] = 'd';
charArray0[6] = 'e';
charArray0[7] = '2';
// try {
uTF8JsonGenerator1.writeString(charArray0, (-342), 1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test197() throws Throwable {
String string0 = "com.fasterxml.jackson.core.util.DefaultPrettyPrinter";
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "com.fasterxml.jackson.core.util.DefaultPrettyPrinter");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "com.fasterxml.jackson.core.util.DefaultPrettyPrinter", false);
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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(1);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
assertNotNull(byteArrayOutputStream0);
MockPrintStream mockPrintStream0 = new MockPrintStream(byteArrayOutputStream0);
assertNotNull(mockPrintStream0);
PrintStream printStream0 = mockPrintStream0.append((CharSequence) "com.fasterxml.jackson.core.util.DefaultPrettyPrinter");
assertEquals(52, byteArrayOutputStream0.size());
assertEquals("com.fasterxml.jackson.core.util.DefaultPrettyPrinter", byteArrayOutputStream0.toString());
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
boolean boolean1 = false;
boolean boolean2 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
assertTrue(boolean2 == boolean0);
assertTrue(boolean2 == boolean1);
assertFalse(boolean2);
MockPrintStream mockPrintStream1 = new MockPrintStream(printStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte) (-103);
byteArray0[1] = (byte) (-31);
byteArray0[2] = (byte) (-115);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 314, (ObjectCodec) null, mockPrintStream1, byteArray0, (-1212), true);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(52, byteArrayOutputStream0.size());
assertEquals("com.fasterxml.jackson.core.util.DefaultPrettyPrinter", byteArrayOutputStream0.toString());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-1212), uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(314, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-103), (byte) (-31), (byte) (-115)}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber(1.0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1212
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test198() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
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);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)78;
byte byte0 = (byte)126;
byteArray0[2] = (byte)126;
byte byte1 = (byte)123;
byteArray0[3] = (byte)123;
byteArray0[4] = (byte) (-34);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 34, (ObjectCodec) null, pipedOutputStream0, byteArray0, 50, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(50, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(34, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)78, (byte)126, (byte)123, (byte) (-34), (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
char char0 = 'z';
char[] charArray0 = new char[5];
charArray0[0] = 'O';
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
charArray0[1] = '@';
charArray0[4] = '@';
charArray0[3] = '1';
// try {
uTF8JsonGenerator0.close();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test199() throws Throwable {
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(422);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(422, charArray0.length);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(charArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-156), (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("0123456789ABCDEF");
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asQuotedUTF8();
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(16, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals(16, serializedString0.charLength());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte byte0 = (byte)1;
uTF8JsonGenerator0.writeString(charArray0, 6, 1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(27, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(422, charArray0.length);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.flush();
// 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 test200() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
byte[] byteArray0 = new byte[1];
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertNull(iOContext0.getEncoding());
assertFalse(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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 128, (ObjectCodec) null, mockPrintStream0, byteArray0, 255, true);
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(255, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(128, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.close();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test201() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2299, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char char0 = 'o';
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char char1 = '\'';
uTF8JsonGenerator0.writeObjectFieldStart("7#9&E}c0<lxkO*7_");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(29, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
Object object0 = uTF8JsonGenerator0.getOutputTarget();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(29, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(object0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
// try {
uTF8JsonGenerator0.writeBoolean(true);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a boolean value, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test202() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
System.setCurrentTimeMillis(1605L);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, fileSystemHandling0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
MockPrintStream mockPrintStream0 = new MockPrintStream(pipedOutputStream0, false);
assertNotNull(mockPrintStream0);
Locale locale0 = Locale.JAPAN;
assertEquals("JPN", locale0.getISO3Country());
assertEquals("JP", locale0.getCountry());
assertEquals("", locale0.getVariant());
assertEquals("ja_JP", locale0.toString());
assertEquals("jpn", locale0.getISO3Language());
assertEquals("ja", locale0.getLanguage());
assertNotNull(locale0);
PrintStream printStream0 = mockPrintStream0.format(locale0, "wP]Rj(y*SfVf", (Object[]) null);
assertEquals("JPN", locale0.getISO3Country());
assertEquals("JP", locale0.getCountry());
assertEquals("", locale0.getVariant());
assertEquals("ja_JP", locale0.toString());
assertEquals("jpn", locale0.getISO3Language());
assertEquals("ja", locale0.getLanguage());
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)28;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, printStream0, byteArray0, 2, true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("JPN", locale0.getISO3Country());
assertEquals("JP", locale0.getCountry());
assertEquals("", locale0.getVariant());
assertEquals("ja_JP", locale0.toString());
assertEquals("jpn", locale0.getISO3Language());
assertEquals("ja", locale0.getLanguage());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)28}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeRaw("wP]Rj(y*SfVf");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("JPN", locale0.getISO3Country());
assertEquals("JP", locale0.getCountry());
assertEquals("", locale0.getVariant());
assertEquals("ja_JP", locale0.toString());
assertEquals("jpn", locale0.getISO3Language());
assertEquals("ja", locale0.getLanguage());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)102}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test203() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 2);
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals((-1), int0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (byte)83, (ObjectCodec) null, mockPrintStream0, byteArray0, 126, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(126, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(3L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(serializedString1, serializedString0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, (byte)71, (byte)71);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test204() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3446, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1855, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3446, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1855, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0._flushBuffer();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test205() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
byte[] byteArray0 = new byte[1];
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((short) (byte)48);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.io.NumberOutput", e);
// }
}
@Test(timeout = 4000)
public void test206() throws Throwable {
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(422);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(422, charArray0.length);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-156), (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("0123456789ABCDEF");
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(16, serializedString0.charLength());
assertNotNull(serializedString0);
byte[] byteArray0 = serializedString0.asQuotedUTF8();
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(16, serializedString0.charLength());
assertEquals(16, byteArray0.length);
assertNotNull(byteArray0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(16, serializedString0.charLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray1 = new byte[8];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[2] = (byte)1;
byteArray1[3] = (byte)1;
byteArray1[4] = (byte)1;
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("0123456789ABCDEF", serializedString0.getValue());
assertEquals("0123456789ABCDEF", serializedString0.toString());
assertEquals(16, serializedString0.charLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(40, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((BigDecimal) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(45, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test207() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(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);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)126;
SerializedString serializedString0 = new SerializedString("V3}R%");
assertEquals("V3}R%", serializedString0.toString());
assertEquals(5, serializedString0.charLength());
assertEquals("V3}R%", serializedString0.getValue());
assertNotNull(serializedString0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (byte)126, (ObjectCodec) null, pipedOutputStream0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals("V3}R%", serializedString0.toString());
assertEquals(5, serializedString0.charLength());
assertEquals("V3}R%", serializedString0.getValue());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString((char[]) null, 1015, (-2450));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
SerializedString serializedString2 = new SerializedString("");
assertEquals(0, serializedString2.charLength());
assertEquals("", serializedString2.getValue());
assertEquals("", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString1));
assertFalse(serializedString2.equals((Object)serializedString0));
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals("V3}R%", serializedString0.toString());
assertEquals(5, serializedString0.charLength());
assertEquals("V3}R%", serializedString0.getValue());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(serializedString0.equals((Object)serializedString1));
assertFalse(serializedString0.equals((Object)serializedString2));
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(serializedString0, serializedString1);
assertNotSame(serializedString0, serializedString2);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(126, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(22, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// try {
uTF8JsonGenerator0._outputSurrogates((byte)83, 1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Incomplete surrogate pair: first char 0x53, second 0x1
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test208() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = '.';
charArray0[2] = '.';
charArray0[3] = 'o';
charArray0[4] = '.';
charArray0[5] = 'o';
charArray0[6] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 224, 0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(7, charArray0.length);
assertArrayEquals(new char[] {'m', '.', '.', 'o', '.', 'o', 'o'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber((short)49);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeStartArray();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(12, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)6;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
byte[] byteArray1 = new byte[0];
assertFalse(byteArray1.equals((Object)byteArray0));
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRaw('Q');
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeString("V");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test209() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
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(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
char[] charArray0 = iOContext1.allocNameCopyBuffer((-377));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(200, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(charArray0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
char[] charArray1 = iOContext1.allocTokenBuffer(0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(charArray1.equals((Object)charArray0));
assertEquals(4000, charArray1.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charArray1, charArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(charArray1);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 1);
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, int0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 33, (ObjectCodec) null, pipedOutputStream0, byteArray0, 1, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(33, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(33, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)34, (byte)32, (byte)34, (byte)0, (byte)0}, byteArray0);
assertSame(iOContext0, iOContext1);
assertSame(serializedString0, serializedString1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray1 = new byte[4];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)81;
byteArray1[1] = (byte)71;
byteArray1[2] = (byte) (-109);
byteArray1[3] = (byte)81;
// try {
uTF8JsonGenerator0.flush();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test210() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
byte[] byteArray0 = new byte[4];
byteArray0[1] = (byte) (-115);
byteArray0[2] = (byte)14;
byteArray0[3] = (byte)126;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
FilterOutputStream filterOutputStream0 = new FilterOutputStream(byteArrayOutputStream0);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(filterOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-526), (ObjectCodec) null, filterOutputStream0, byteArray0, 3, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-526), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(4, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte) (-115), (byte)14, (byte)126}, byteArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
int[] intArray0 = new int[1];
intArray0[0] = (int) (byte)14;
uTF8JsonGenerator0._outputEscapes = intArray0;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-526), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
uTF8JsonGenerator0.close();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, byteArrayOutputStream0.size());
assertEquals("\u0000\uFFFD\u000E", byteArrayOutputStream0.toString());
assertEquals((-526), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(4, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte) (-115), (byte)14, (byte)126}, byteArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test211() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
String string0 = " in a comment";
String string1 = "";
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 943, (ObjectCodec) null, mockPrintStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(943, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[6];
charArray0[0] = '_';
charArray0[1] = 'r';
charArray0[2] = 'r';
charArray0[3] = 'y';
charArray0[4] = 'y';
charArray0[5] = 'Q';
boolean boolean1 = false;
char char0 = 'F';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw((SerializableString) null);
// 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 test212() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2299, (ObjectCodec) null, (OutputStream) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char char0 = 'o';
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char char1 = '\'';
uTF8JsonGenerator0.writeObjectFieldStart("7#9&E}c0<lxkO*7_");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(29, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
Object object0 = uTF8JsonGenerator0.getOutputTarget();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(29, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2299, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNull(object0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(pipedInputStream0, pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(sequenceInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeObject(sequenceInputStream0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // No ObjectCodec defined for the generator, can only serialize simple wrapper types (type passed java.io.SequenceInputStream)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test213() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)114;
byteArray0[1] = (byte) (-97);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 60, (ObjectCodec) null, (OutputStream) null, byteArray0, 3, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(60, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)114, (byte) (-97)}, byteArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0._verifyValueWrite("Y");
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(60, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)114, (byte) (-97)}, byteArray0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test214() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, objectArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-2736), (-3070));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, objectArray0.length);
assertEquals(19, charArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = BigDecimal.ONE;
assertEquals((short)1, bigDecimal0.shortValue());
assertEquals((byte)1, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals((short)1, bigDecimal0.shortValue());
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName("E{\"e<D%!)w[");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
int int0 = uTF8JsonGenerator0.getOutputBuffered();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, objectArray0.length);
assertEquals(20, int0);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test215() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
char[] charArray0 = new char[3];
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertFalse(boolean1 == boolean0);
assertTrue(boolean1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 32, false);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(32, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArrayBuilder0.NO_BYTES, (-4130), 0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test216() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(8000);
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertFalse(file0.isDirectory());
assertEquals(1L, file0.length());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 3, 55296);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.flush();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertEquals(4L, file0.length());
assertFalse(file0.isDirectory());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test217() throws Throwable {
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, mockPrintStream0, byteArray0, 0, true);
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[3];
charArray0[0] = '!';
charArray0[1] = 'i';
charArray0[2] = 'y';
uTF8JsonGenerator0.writeRaw(charArray0, 3, (-2958));
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canWrite());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getTotalSpace());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertEquals(1, byteArray0.length);
assertEquals(3, charArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertArrayEquals(new char[] {'!', 'i', 'y'}, charArray0);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((short) (byte)56);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.io.NumberOutput", e);
// }
}
@Test(timeout = 4000)
public void test218() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
iOContext0.releaseConcatBuffer((char[]) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, objectArray0.length);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp/ in a comment0");
boolean boolean0 = FileSystemHandling.setPermissions(evoSuiteFile0, false, false, true);
assertTrue(boolean0);
charArray0[6] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-2736), (-3070));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, objectArray0.length);
assertEquals(19, charArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
BigDecimal bigDecimal0 = BigDecimal.ONE;
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((byte)1, bigDecimal0.byteValue());
assertEquals((short)1, bigDecimal0.shortValue());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeFieldName("E{\"e<D%!)w[");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeBoolean(false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.canWrite());
assertTrue(file0.isAbsolute());
assertTrue(file0.canExecute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test219() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 99, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext3);
byte[] byteArray0 = new byte[3];
byteArray0[2] = (byte)64;
byteArray0[1] = (byte)0;
IOContext iOContext4 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext4.getEncoding());
assertFalse(iOContext4.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext4.equals((Object)iOContext2));
assertFalse(iOContext4.equals((Object)iOContext0));
assertFalse(iOContext4.equals((Object)iOContext3));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext4);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(iOContext4, iOContext2);
assertNotSame(iOContext4, iOContext0);
assertNotSame(iOContext4, iOContext3);
assertSame(iOContext4, iOContext1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext4);
byteArray0[2] = (byte)0;
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 2, (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)0, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext4));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext4);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator1.writeNumber((float) (byte)0);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)48, (byte)46, (byte)48}, byteArray0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext4);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.close();
// 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 test220() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
iOContext0.releaseBase64Buffer((byte[]) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 249, (ObjectCodec) null, mockPrintStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(249, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(249, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber((BigInteger) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.exists());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(249, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte) (-121);
byteArray0[1] = (byte) (-115);
byteArray0[2] = (byte)91;
byteArray0[3] = (byte)14;
byteArray0[4] = (byte)71;
byteArray0[5] = (byte) (-64);
byteArray0[6] = (byte)14;
byteArray0[7] = (byte) (-124);
byteArray0[8] = (byte)83;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, (byte) (-115), (byte) (-124));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test221() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(579);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNotNull(byteArrayBuilder0);
BufferedOutputStream bufferedOutputStream0 = new BufferedOutputStream(byteArrayBuilder0, 579);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertNotNull(bufferedOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-1838), (ObjectCodec) null, bufferedOutputStream0, byteArrayBuilder0.NO_BYTES, (-2698), false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-2698), uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-1838), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeStartArray();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -2698
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test222() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, objectArray0.length);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
SerializedString serializedString0 = new SerializedString("");
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canExecute());
assertEquals(" in a comment0", file0.getName());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((short)10, bigInteger0.shortValue());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)1;
byteArray0[3] = (byte) (-12);
byteArray0[4] = (byte)1;
byteArray0[5] = (byte)1;
byteArray0[6] = (byte)1;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 3258, 45);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 3258
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test223() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte byte0 = (byte) (-64);
char[] charArray0 = iOContext1.allocTokenBuffer(512);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)83;
byteArray0[1] = (byte)0;
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 127);
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals((-1), int0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 3, (ObjectCodec) null, pipedOutputStream0, byteArray0, 10, true);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(10, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)0}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// try {
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test224() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)126;
byteArray0[3] = (byte) (-115);
byteArray0[4] = (byte)14;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 116, (ObjectCodec) null, pipedOutputStream0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(116, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(116, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
BigInteger bigInteger0 = BigInteger.TEN;
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(116, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((byte)10, bigInteger0.byteValue());
assertEquals((short)10, bigInteger0.shortValue());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 2, 123);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 6
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test225() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)20;
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, (-128), (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)20, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(20, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)20, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
char[] charArray0 = new char[17];
charArray0[0] = 'f';
charArray0[1] = 'd';
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeString(charArray0, (-944), 1);
// 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 test226() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
char[] charArray0 = new char[3];
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArrayBuilder0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1354, false);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'O'}, charArray0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
ByteArrayBuilder byteArrayBuilder1 = (ByteArrayBuilder)uTF8JsonGenerator0.getOutputTarget();
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayBuilder1.getCurrentSegmentLength());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'O'}, charArray0);
assertSame(byteArrayBuilder0, byteArrayBuilder1);
assertSame(byteArrayBuilder1, byteArrayBuilder0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(byteArrayBuilder1);
IOContext iOContext1 = new IOContext(bufferRecycler0, byteArrayBuilder1, true);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayBuilder1.getCurrentSegmentLength());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'O'}, charArray0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayBuilder1.getCurrentSegmentLength());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'O'}, charArray0);
assertSame(byteArrayBuilder0, byteArrayBuilder1);
assertSame(byteArrayBuilder1, byteArrayBuilder0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext2);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, 2, (ObjectCodec) null, byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayBuilder1.getCurrentSegmentLength());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'O'}, charArray0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1.writeString(charArray0, 1356, (-2578));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, byteArrayBuilder1.getCurrentSegmentLength());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'O'}, charArray0);
assertSame(byteArrayBuilder0, byteArrayBuilder1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(byteArrayBuilder1, byteArrayBuilder0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.flush();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test227() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
char[] charArray0 = iOContext1.allocTokenBuffer(0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 1);
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(1, int0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 33, (ObjectCodec) null, pipedOutputStream0, byteArray0, 1, true);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(33, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)32, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(33, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)34, (byte)32, (byte)34, (byte)0, (byte)0}, byteArray0);
assertSame(iOContext0, iOContext1);
assertSame(serializedString0, serializedString1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
byte[] byteArray1 = new byte[4];
assertFalse(byteArray1.equals((Object)byteArray0));
byteArray1[0] = (byte)81;
byteArray1[1] = (byte)71;
byteArray1[2] = (byte) (-109);
byteArray1[3] = (byte)81;
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArray1, 10, 10);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test228() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("AL& QZ\")I%L");
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
byte[] byteArray0 = new byte[7];
byteArray0[0] = (byte) (-46);
byteArray0[2] = (byte) (-109);
byteArray0[3] = (byte)47;
byteArray0[4] = (byte) (-59);
byteArray0[5] = (byte)35;
byteArray0[6] = (byte)2;
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertEquals(7, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-46), (byte)0, (byte) (-109), (byte)47, (byte) (-59), (byte)35, (byte)2}, byteArray0);
assertFalse(boolean0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
SerializedString serializedString1 = new SerializedString("0123456789ABCDEF");
assertEquals(16, serializedString1.charLength());
assertEquals("0123456789ABCDEF", serializedString1.toString());
assertEquals("0123456789ABCDEF", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
byte[] byteArray1 = serializedString0.asUnquotedUTF8();
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(11, byteArray1.length);
assertNotSame(serializedString0, serializedString1);
assertNotSame(byteArray1, byteArray0);
assertNotNull(byteArray1);
byte[] byteArray2 = serializedString0.asQuotedUTF8();
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertFalse(byteArray2.equals((Object)byteArray0));
assertFalse(byteArray2.equals((Object)byteArray1));
assertEquals(12, byteArray2.length);
assertNotSame(serializedString0, serializedString1);
assertNotSame(byteArray2, byteArray0);
assertNotSame(byteArray2, byteArray1);
assertNotNull(byteArray2);
IOContext iOContext1 = new IOContext(bufferRecycler0, "Can not ", true);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, (OutputStream) null, byteArray1, 2, false);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertFalse(serializedString0.equals((Object)serializedString1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertFalse(byteArray1.equals((Object)byteArray2));
assertEquals(11, byteArray1.length);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeString((char[]) null, (-944), 56320);
// 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 test229() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "HOrocs7V", true);
assertTrue(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);
assertNotNull(iOContext0);
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertNotNull(byteArrayOutputStream0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte) (-117);
byteArray0[1] = (byte)22;
byteArray0[2] = (byte)43;
byteArray0[3] = (byte)6;
byteArray0[4] = (byte)26;
byteArray0[5] = (byte) (-2);
byteArray0[6] = (byte) (-126);
byteArray0[7] = (byte)3;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, byteArrayOutputStream0, byteArray0, 2, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(1, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(8, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-117), (byte)22, (byte)43, (byte)6, (byte)26, (byte) (-2), (byte) (-126), (byte)3}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName("HOrocs7V");
// 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 test230() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 3, (ObjectCodec) null, pipedOutputStream0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw((String) null, 0, 3032);
// 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 test231() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteBuffer byteBuffer0 = ByteBuffer.wrap(byteArray0);
assertTrue(byteBuffer0.hasArray());
assertEquals(9, byteBuffer0.remaining());
assertEquals(0, byteBuffer0.position());
assertFalse(byteBuffer0.isReadOnly());
assertEquals(9, byteBuffer0.capacity());
assertEquals("java.nio.HeapByteBuffer[pos=0 lim=9 cap=9]", byteBuffer0.toString());
assertEquals(0, byteBuffer0.arrayOffset());
assertFalse(byteBuffer0.isDirect());
assertEquals(9, byteBuffer0.limit());
assertTrue(byteBuffer0.hasRemaining());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(byteBuffer0);
int int0 = serializedString0.putUnquotedUTF8(byteBuffer0);
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertTrue(byteBuffer0.hasArray());
assertEquals(9, byteBuffer0.remaining());
assertEquals(0, byteBuffer0.position());
assertFalse(byteBuffer0.isReadOnly());
assertEquals(9, byteBuffer0.capacity());
assertEquals("java.nio.HeapByteBuffer[pos=0 lim=9 cap=9]", byteBuffer0.toString());
assertEquals(0, byteBuffer0.arrayOffset());
assertFalse(byteBuffer0.isDirect());
assertEquals(9, byteBuffer0.limit());
assertTrue(byteBuffer0.hasRemaining());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals((-1), int0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
double double0 = bigInteger0.doubleValue();
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0.0, double0, 0.01);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(28, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(serializedString0.equals((Object)serializedString1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(serializedString0, serializedString1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator1.writeFieldName((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(41, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals(41, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(serializedString0.equals((Object)serializedString1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(serializedString0, serializedString1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator1._releaseBuffers();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(41, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(41, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test232() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 228, (ObjectCodec) null, pipedOutputStream0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(228, uTF8JsonGenerator0.getFeatureMask());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(228, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
SerializedString serializedString1 = new SerializedString("d?pI=");
assertEquals("d?pI=", serializedString1.getValue());
assertEquals("d?pI=", serializedString1.toString());
assertEquals(5, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
SerializedString serializedString2 = new SerializedString("~6y&rh,aR3j*%#@");
assertEquals(15, serializedString2.charLength());
assertEquals("~6y&rh,aR3j*%#@", serializedString2.getValue());
assertEquals("~6y&rh,aR3j*%#@", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
byte[] byteArray1 = serializedString2.asQuotedUTF8();
assertEquals(15, serializedString2.charLength());
assertEquals("~6y&rh,aR3j*%#@", serializedString2.getValue());
assertEquals("~6y&rh,aR3j*%#@", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(15, byteArray1.length);
assertNotSame(serializedString2, serializedString0);
assertNotSame(serializedString2, serializedString1);
assertNotSame(byteArray1, byteArray0);
assertNotNull(byteArray1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(5, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(228, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertFalse(serializedString0.equals((Object)serializedString2));
assertFalse(serializedString0.equals((Object)serializedString1));
assertSame(iOContext0, iOContext1);
assertNotSame(serializedString0, serializedString2);
assertNotSame(serializedString0, serializedString1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeUTF8String(byteArray0, 3, 3);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(26, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(228, uTF8JsonGenerator0.getFeatureMask());
assertFalse(byteArray0.equals((Object)byteArray1));
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertSame(iOContext0, iOContext1);
assertNotSame(byteArray0, byteArray1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray1, 194, 194);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 194
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test233() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, (-128), (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)1, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, byteArray0.length);
assertArrayEquals(new byte[] {(byte)1, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
char[] charArray0 = new char[2];
charArray0[0] = 'e';
charArray0[1] = 'd';
// Undeclared exception!
uTF8JsonGenerator1.writeString(charArray0, (-944), 1);
}
@Test(timeout = 4000)
public void test234() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertNotNull(mockPrintStream1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2831, false);
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(2831, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(filteringGeneratorDelegate0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.setEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(iOContext0, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertEquals(383, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNull(objectCodec0);
filteringGeneratorDelegate0.writeStartArray(8000);
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(1L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)91}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.close();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertEquals(3L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
UTF8JsonGenerator uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext0, 3366, (ObjectCodec) null, mockPrintStream1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertEquals(3L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(0, uTF8JsonGenerator2.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator2.getFormatFeatures());
assertEquals(3366, uTF8JsonGenerator2.getFeatureMask());
assertTrue(uTF8JsonGenerator2.canOmitFields());
assertFalse(uTF8JsonGenerator2.isClosed());
assertFalse(uTF8JsonGenerator2.canWriteTypeId());
assertFalse(uTF8JsonGenerator2.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator2.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator2.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator2.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator0));
assertFalse(uTF8JsonGenerator2.equals((Object)uTF8JsonGenerator1));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator2);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator1._rootValueSeparator;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)93}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals(" in a comment0", file0.getName());
assertEquals(3L, file0.length());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals("/tmp/ in a comment0", file0.toString());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertEquals(" ", serializedString1.toString());
assertTrue(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(2831, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(57343, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(mockPrintStream0.equals((Object)mockPrintStream1));
assertFalse(printStream0.equals((Object)mockPrintStream1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(mockPrintStream1.equals((Object)mockPrintStream0));
assertFalse(mockPrintStream1.equals((Object)printStream0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator2));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertNotSame(mockPrintStream0, mockPrintStream1);
assertSame(serializedString1, serializedString0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(printStream0, mockPrintStream1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(mockPrintStream1, mockPrintStream0);
assertNotSame(mockPrintStream1, printStream0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator2);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
uTF8JsonGenerator1.writeNumber(0.0F);
}
@Test(timeout = 4000)
public void test235() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)83;
byteArray0[1] = (byte)83;
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)83;
IOContext iOContext0 = new IOContext(bufferRecycler0, file0, false);
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream(file0);
assertNotNull(mockFileOutputStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, mockFileOutputStream0, byteArray0, (byte)83, false);
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(83, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(5, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83, (byte)83, (byte)0, (byte)0, (byte)83}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
iOContext0.releaseTokenBuffer((char[]) null);
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
char[] charArray0 = new char[0];
uTF8JsonGenerator0._charBuffer = charArray0;
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertTrue(file0.isAbsolute());
assertFalse(file0.isDirectory());
assertEquals(" in a comment02.7.7-SNAPSHOT", file0.getName());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment02.7.7-SNAPSHOT", file0.toString());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals("/tmp", file0.getParent());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(83, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((double) 2);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test236() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
char[] charArray0 = new char[3];
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
ObjectCodec objectCodec0 = null;
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3351));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
boolean boolean1 = false;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1354, false);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', 'O'}, charArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
int int0 = 2;
String string0 = "-5";
int int1 = 1749;
int int2 = 1356;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((-214.58F));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test237() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 376, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(376, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(JsonEncoding.UTF16_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext3);
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(376, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(376, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(filteringGeneratorDelegate0);
ObjectCodec objectCodec0 = filteringGeneratorDelegate0.getCodec();
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(376, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(376, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNull(objectCodec0);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, 4925, (ObjectCodec) null, mockPrintStream0, byteArray0, 376, true);
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(376, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(4925, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)32}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(serializedString0, serializedString1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator1.writeFieldName((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(4L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getFreeSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(4925, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(serializedString0, serializedString1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
}
@Test(timeout = 4000)
public void test238() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte) (-109);
byteArray0[3] = (byte)123;
byteArray0[4] = (byte) (-34);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 34, (ObjectCodec) null, pipedOutputStream0, byteArray0, 50, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(34, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(50, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)83, (byte) (-109), (byte)123, (byte) (-34), (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
char[] charArray0 = new char[5];
charArray0[0] = 'O';
charArray0[1] = '@';
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = new SerializedString("");
assertEquals("", serializedString1.toString());
assertEquals(0, serializedString1.charLength());
assertEquals("", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
// try {
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test239() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)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);
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 12, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(12, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
ByteBuffer byteBuffer0 = ByteBuffer.allocateDirect(48);
assertFalse(byteBuffer0.isReadOnly());
assertEquals(48, byteBuffer0.capacity());
assertEquals(48, byteBuffer0.remaining());
assertEquals(48, byteBuffer0.limit());
assertTrue(byteBuffer0.isDirect());
assertFalse(byteBuffer0.hasArray());
assertEquals(0, byteBuffer0.position());
assertEquals("java.nio.DirectByteBuffer[pos=0 lim=48 cap=48]", byteBuffer0.toString());
assertTrue(byteBuffer0.hasRemaining());
assertNotNull(byteBuffer0);
int int0 = serializedString0.putUnquotedUTF8(byteBuffer0);
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertFalse(byteBuffer0.isReadOnly());
assertEquals(48, byteBuffer0.capacity());
assertEquals("java.nio.DirectByteBuffer[pos=11 lim=48 cap=48]", byteBuffer0.toString());
assertEquals(48, byteBuffer0.limit());
assertTrue(byteBuffer0.isDirect());
assertFalse(byteBuffer0.hasArray());
assertEquals(37, byteBuffer0.remaining());
assertEquals(11, byteBuffer0.position());
assertTrue(byteBuffer0.hasRemaining());
assertEquals(11, int0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((SerializableString) null);
// 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 test240() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, objectArray0.length);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
Object object0 = uTF8JsonGenerator0.getCurrentValue();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(object0);
uTF8JsonGenerator0.writeObjectField("\"", (Object) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isFile());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.canExecute());
assertEquals("/tmp", file0.getParent());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.exists());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.length());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.isAbsolute());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
// try {
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test241() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(textBuffer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0._outputTail = 35;
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(38, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char[] charArray0 = new char[8];
SerializedString serializedString2 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeString((SerializableString) serializedString2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(52, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals(11, serializedString2.charLength());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertTrue(serializedString2.equals((Object)serializedString0));
assertFalse(serializedString2.equals((Object)serializedString1));
assertNotSame(serializedString2, serializedString1);
assertNotSame(serializedString2, serializedString0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(61, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(8, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString3 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString3.charLength());
assertEquals(" ", serializedString3.getValue());
assertEquals(" ", serializedString3.toString());
assertFalse(serializedString3.equals((Object)serializedString2));
assertFalse(serializedString3.equals((Object)serializedString0));
assertSame(serializedString3, serializedString1);
assertNotSame(serializedString3, serializedString2);
assertNotSame(serializedString3, serializedString0);
assertNotNull(serializedString3);
SerializedString serializedString4 = new SerializedString("");
assertEquals("", serializedString4.toString());
assertEquals("", serializedString4.getValue());
assertEquals(0, serializedString4.charLength());
assertFalse(serializedString4.equals((Object)serializedString2));
assertFalse(serializedString4.equals((Object)serializedString0));
assertFalse(serializedString4.equals((Object)serializedString1));
assertFalse(serializedString4.equals((Object)serializedString3));
assertNotNull(serializedString4);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString4);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(62, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("", serializedString4.toString());
assertEquals("", serializedString4.getValue());
assertEquals(0, serializedString4.charLength());
assertFalse(serializedString4.equals((Object)serializedString2));
assertFalse(serializedString4.equals((Object)serializedString0));
assertFalse(serializedString4.equals((Object)serializedString1));
assertFalse(serializedString4.equals((Object)serializedString3));
assertNotSame(serializedString4, serializedString2);
assertNotSame(serializedString4, serializedString0);
assertNotSame(serializedString4, serializedString1);
assertNotSame(serializedString4, serializedString3);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// try {
uTF8JsonGenerator0._outputSurrogates((-276), (-276));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Incomplete surrogate pair: first char 0xfffffeec, second 0xfffffeec
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test242() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
EvoSuiteFile evoSuiteFile0 = new EvoSuiteFile("/tmp");
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-75);
boolean boolean0 = FileSystemHandling.appendDataToFile(evoSuiteFile0, byteArray0);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-75)}, byteArray0);
assertFalse(boolean0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-2736), (-3070));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
assertEquals(19, charArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
BigDecimal bigDecimal0 = new BigDecimal(661.447);
assertEquals((short)661, bigDecimal0.shortValue());
assertEquals((byte) (-107), bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals((short)661, bigDecimal0.shortValue());
assertEquals((byte) (-107), bigDecimal0.byteValue());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(47, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeFieldName("");
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(48, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeBoolean(false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(54, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeRaw(charArray0, 2, 2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getTotalSpace());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(56, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
assertEquals(19, charArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
}
@Test(timeout = 4000)
public void test243() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char char0 = 'o';
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
assertEquals("", serializedString0.toString());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char char1 = '\'';
uTF8JsonGenerator0.writeObjectFieldStart("7#9&E}c0<lxkO*7_");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(26, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
Object object0 = uTF8JsonGenerator0.getOutputTarget();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(26, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(object0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(pipedInputStream0, pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(sequenceInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeObject(sequenceInputStream0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // No ObjectCodec defined for the generator, can only serialize simple wrapper types (type passed java.io.SequenceInputStream)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test244() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(11, serializedString0.charLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
byte[] byteArray0 = new byte[9];
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8, (ObjectCodec) null, (OutputStream) null, byteArray0, 8, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(8, uTF8JsonGenerator1.getOutputBuffered());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(8, uTF8JsonGenerator1.getFeatureMask());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
// Undeclared exception!
// try {
uTF8JsonGenerator1._writePPFieldName(serializedString0);
// 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 test245() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-156), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
SerializedString serializedString1 = new SerializedString("0123456789ABCDEF");
assertEquals("0123456789ABCDEF", serializedString1.getValue());
assertEquals("0123456789ABCDEF", serializedString1.toString());
assertEquals(16, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
byte[] byteArray0 = serializedString1.asUnquotedUTF8();
assertEquals("0123456789ABCDEF", serializedString1.getValue());
assertEquals("0123456789ABCDEF", serializedString1.toString());
assertEquals(16, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertEquals(16, byteArray0.length);
assertNotSame(serializedString1, serializedString0);
assertNotNull(byteArray0);
byte[] byteArray1 = serializedString1.asQuotedUTF8();
assertEquals("0123456789ABCDEF", serializedString1.getValue());
assertEquals("0123456789ABCDEF", serializedString1.toString());
assertEquals(16, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(16, byteArray1.length);
assertNotSame(serializedString1, serializedString0);
assertNotSame(byteArray1, byteArray0);
assertNotNull(byteArray1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(32, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("0123456789ABCDEF", serializedString1.getValue());
assertEquals("0123456789ABCDEF", serializedString1.toString());
assertEquals(16, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
byte[] byteArray2 = new byte[8];
assertFalse(byteArray2.equals((Object)byteArray0));
assertFalse(byteArray2.equals((Object)byteArray1));
byteArray2[2] = (byte)1;
byteArray2[3] = (byte)1;
byteArray2[4] = (byte)1;
SerializedString serializedString2 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString2.getValue());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString1));
assertFalse(serializedString2.equals((Object)serializedString0));
assertNotSame(serializedString2, serializedString1);
assertNotSame(serializedString2, serializedString0);
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(34, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(" ", serializedString2.getValue());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString1));
assertFalse(serializedString2.equals((Object)serializedString0));
assertNotSame(serializedString2, serializedString1);
assertNotSame(serializedString2, serializedString0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
BigInteger bigInteger0 = BigInteger.ZERO;
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertNotNull(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(38, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
}
@Test(timeout = 4000)
public void test246() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext3);
// Undeclared exception!
// try {
uTF8JsonGenerator0._verifyPrettyValueWrite("", 2);
// 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 test247() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(textBuffer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0._outputTail = 35;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(38, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char[] charArray0 = new char[8];
charArray0[0] = '';
charArray0[1] = '\'';
charArray0[2] = '';
uTF8JsonGenerator0.writeObjectFieldStart("");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(41, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
charArray0[3] = 'm';
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)34;
byteArray0[1] = (byte)49;
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 125, 17);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a string, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test248() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)126;
byteArray0[3] = (byte)123;
byteArray0[5] = (byte) (-34);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 34, (ObjectCodec) null, pipedOutputStream0, byteArray0, 50, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(50, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(34, uTF8JsonGenerator0.getFeatureMask());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)83, (byte)126, (byte)123, (byte)0, (byte) (-34)}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, (-2862), (byte) (-64));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test249() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
double double0 = bigInteger0.doubleValue();
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0.0, double0, 0.01);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.toString());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(28, uTF8JsonGenerator0.getOutputBuffered());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(serializedString0.equals((Object)serializedString1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(serializedString0, serializedString1);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator1.writeFieldName((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(41, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(41, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(serializedString0.equals((Object)serializedString1));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(serializedString0, serializedString1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
}
@Test(timeout = 4000)
public void test250() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
byte[] byteArray1 = serializedString0.asUnquotedUTF8();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertEquals(1, byteArray1.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertArrayEquals(new byte[] {(byte)32}, byteArray1);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(byteArray0, byteArray1);
assertNotSame(byteArray1, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(byteArray1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 21, (ObjectCodec) null, mockPrintStream0, byteArray0, 125, false);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(125, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(21, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
uTF8JsonGenerator1.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(" in a comment0", file0.getName());
assertEquals(3L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(21, uTF8JsonGenerator1.getFeatureMask());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotSame(byteArray0, byteArray1);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator1.writeStartObject();
assertEquals(" in a comment0", file0.getName());
assertEquals(5L, file0.length());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isDirectory());
assertTrue(file0.isAbsolute());
assertTrue(file0.canWrite());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.canExecute());
assertTrue(file0.exists());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.canRead());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.isFile());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(21, uTF8JsonGenerator1.getFeatureMask());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(byteArray0.equals((Object)byteArray1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)123}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertNotSame(byteArray0, byteArray1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
UTF8JsonGenerator uTF8JsonGenerator2 = null;
// try {
uTF8JsonGenerator2 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream0, byteArray0, 50, false);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test251() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext3);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw((char[]) null, 3, 2304);
// 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 test252() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte) (-109);
byteArray0[3] = (byte)123;
byteArray0[4] = (byte) (-34);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 34, (ObjectCodec) null, pipedOutputStream0, byteArray0, 50, false);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(34, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(50, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(6, byteArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)83, (byte) (-109), (byte)123, (byte) (-34), (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
char[] charArray0 = new char[5];
charArray0[0] = 'O';
charArray0[1] = '@';
charArray0[2] = '@';
charArray0[3] = '1';
charArray0[4] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-1249), (int) (byte) (-109));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(34, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(50, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(6, byteArray0.length);
assertEquals(5, charArray0.length);
assertArrayEquals(new byte[] {(byte) (-64), (byte)83, (byte) (-109), (byte)123, (byte) (-34), (byte)0}, byteArray0);
assertArrayEquals(new char[] {'O', '@', '@', '1', 'z'}, charArray0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = new BigDecimal((double) (byte)123);
assertEquals((short)123, bigDecimal0.shortValue());
assertEquals((byte)123, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
// try {
uTF8JsonGenerator0.writeNumber(bigDecimal0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test253() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 99, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
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(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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)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);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertNotNull(tokenFilter0);
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext2);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)64;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, false);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(0, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(filteringGeneratorDelegate0);
filteringGeneratorDelegate0.writeStartArray(1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals(0, filteringGeneratorDelegate0.getFormatFeatures());
assertFalse(filteringGeneratorDelegate0.canWriteObjectId());
assertFalse(filteringGeneratorDelegate0.canWriteFormattedNumbers());
assertTrue(filteringGeneratorDelegate0.canOmitFields());
assertFalse(filteringGeneratorDelegate0.canWriteTypeId());
assertEquals(0, filteringGeneratorDelegate0.getMatchCount());
assertEquals(0, filteringGeneratorDelegate0.getHighestEscapedChar());
assertEquals(1, filteringGeneratorDelegate0.getOutputBuffered());
assertFalse(filteringGeneratorDelegate0.canWriteBinaryNatively());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.close();
// 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 test254() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
uTF8JsonGenerator0.writeNull();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char char0 = 'o';
SerializedString serializedString0 = new SerializedString("");
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
char char1 = '\'';
uTF8JsonGenerator0.writeObjectFieldStart("7#9&E}c0<lxkO*7_");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(26, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
Object object0 = uTF8JsonGenerator0.getOutputTarget();
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(26, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNull(object0);
PipedInputStream pipedInputStream0 = new PipedInputStream();
assertEquals(0, pipedInputStream0.available());
assertNotNull(pipedInputStream0);
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(pipedInputStream0, pipedInputStream0);
assertEquals(0, pipedInputStream0.available());
assertNotNull(sequenceInputStream0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeObject(sequenceInputStream0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // No ObjectCodec defined for the generator, can only serialize simple wrapper types (type passed java.io.SequenceInputStream)
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test255() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, (-2736), true);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-2736), uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[6];
charArray0[0] = 'L';
charArray0[1] = 'A';
charArray0[2] = 'Y';
charArray0[3] = ' ';
charArray0[4] = 'c';
charArray0[5] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, 1059, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-2736), uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(6, charArray0.length);
assertArrayEquals(new char[] {'L', 'A', 'Y', ' ', 'c', 'z'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = new BigDecimal((-1.0));
assertEquals((short) (-1), bigDecimal0.shortValue());
assertEquals((byte) (-1), bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber(bigDecimal0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -2736
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test256() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
byte[] byteArray0 = new byte[9];
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8, (ObjectCodec) null, (OutputStream) null, byteArray0, 8, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(8, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.isClosed());
assertEquals(8, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeFieldName((SerializableString) serializedString0);
// 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 test257() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
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(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
byte[] byteArray0 = new byte[9];
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext2, iOContext3);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(iOContext3);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8, (ObjectCodec) null, (OutputStream) null, byteArray0, 8, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(8, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator1.writeRaw((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(9, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertEquals(8, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)32}, byteArray0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeString((String) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator0.equals((Object)uTF8JsonGenerator1));
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
}
@Test(timeout = 4000)
public void test258() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-156), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[3];
charArray0[0] = 'o';
charArray0[1] = 'o';
charArray0[2] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 3, 0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'o', 'o', 'o'}, charArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeStartArray();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
SerializedString serializedString0 = new SerializedString("start an array");
assertEquals("start an array", serializedString0.getValue());
assertEquals(14, serializedString0.charLength());
assertEquals("start an array", serializedString0.toString());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(18, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals("start an array", serializedString0.getValue());
assertEquals(14, serializedString0.charLength());
assertEquals("start an array", serializedString0.toString());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
String string0 = "com.fasterxml.jackson.core.JsonParser$Feature";
uTF8JsonGenerator0.writeRaw("com.fasterxml.jackson.core.JsonParser$Feature");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals((-156), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(63, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
String string1 = "IGNORE_UNDEFINED";
Base64Variant base64Variant0 = null;
// try {
base64Variant0 = new Base64Variant("com.fasterxml.jackson.core.JsonParser$Feature", "IGNORE_UNDEFINED", true, 'o', 39);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Base64Alphabet length must be exactly 64 (was 16)
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test259() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("AL& QZ\")I%L");
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(14, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
SerializedString serializedString1 = new SerializedString("0123456789ABCDEF");
assertEquals("0123456789ABCDEF", serializedString1.getValue());
assertEquals("0123456789ABCDEF", serializedString1.toString());
assertEquals(16, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
byte[] byteArray0 = serializedString0.asUnquotedUTF8();
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertEquals(11, byteArray0.length);
assertNotSame(serializedString0, serializedString1);
assertNotNull(byteArray0);
byte[] byteArray1 = serializedString0.asQuotedUTF8();
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(12, byteArray1.length);
assertNotSame(serializedString0, serializedString1);
assertNotSame(byteArray1, byteArray0);
assertNotNull(byteArray1);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(29, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertNotSame(serializedString0, serializedString1);
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(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeUTF8String(byteArray1, 3, 2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(34, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(12, byteArray1.length);
assertNotSame(serializedString0, serializedString1);
assertNotSame(byteArray1, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeUTF8String(byteArray1, 3, 3);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(40, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("AL& QZ\")I%L", serializedString0.toString());
assertEquals("AL& QZ\")I%L", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertFalse(serializedString0.equals((Object)serializedString1));
assertFalse(byteArray1.equals((Object)byteArray0));
assertEquals(12, byteArray1.length);
assertNotSame(serializedString0, serializedString1);
assertNotSame(byteArray1, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
}
@Test(timeout = 4000)
public void test260() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(textBuffer0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
uTF8JsonGenerator0._outputTail = 35;
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(35, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(38, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
char[] charArray0 = new char[8];
SerializedString serializedString2 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals(11, serializedString2.charLength());
assertFalse(serializedString2.equals((Object)serializedString1));
assertTrue(serializedString2.equals((Object)serializedString0));
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeString((SerializableString) serializedString2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(52, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals("e/o=,L$?3bi", serializedString2.toString());
assertEquals("e/o=,L$?3bi", serializedString2.getValue());
assertEquals(11, serializedString2.charLength());
assertFalse(serializedString2.equals((Object)serializedString1));
assertTrue(serializedString2.equals((Object)serializedString0));
assertNotSame(serializedString2, serializedString0);
assertNotSame(serializedString2, serializedString1);
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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(61, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(8, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(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(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString2);
// 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 test261() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertNotNull(serializedString0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
ByteBuffer byteBuffer0 = ByteBuffer.allocateDirect(57343);
assertTrue(byteBuffer0.isDirect());
assertTrue(byteBuffer0.hasRemaining());
assertEquals(57343, byteBuffer0.limit());
assertFalse(byteBuffer0.hasArray());
assertEquals(0, byteBuffer0.position());
assertEquals(57343, byteBuffer0.remaining());
assertFalse(byteBuffer0.isReadOnly());
assertEquals("java.nio.DirectByteBuffer[pos=0 lim=57343 cap=57343]", byteBuffer0.toString());
assertEquals(57343, byteBuffer0.capacity());
assertNotNull(byteBuffer0);
int int0 = serializedString1.putQuotedUTF8(byteBuffer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertTrue(byteBuffer0.isDirect());
assertTrue(byteBuffer0.hasRemaining());
assertEquals(57343, byteBuffer0.limit());
assertFalse(byteBuffer0.hasArray());
assertEquals("java.nio.DirectByteBuffer[pos=1 lim=57343 cap=57343]", byteBuffer0.toString());
assertEquals(57342, byteBuffer0.remaining());
assertFalse(byteBuffer0.isReadOnly());
assertEquals(1, byteBuffer0.position());
assertEquals(57343, byteBuffer0.capacity());
assertFalse(serializedString1.equals((Object)serializedString0));
assertEquals(1, int0);
assertNotSame(serializedString1, serializedString0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char[] charArray0 = new char[8];
charArray0[0] = 'r';
charArray0[1] = '\'';
charArray0[2] = 'o';
charArray0[3] = 'm';
charArray0[4] = 'v';
charArray0[5] = 'r';
charArray0[6] = '@';
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeFieldName("e/o=,L$?3bi");
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeBoolean(true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(20, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
}
@Test(timeout = 4000)
public void test262() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
char[] charArray0 = new char[19];
Object object0 = uTF8JsonGenerator0.getCurrentValue();
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNull(object0);
uTF8JsonGenerator0.writeObjectField("\"", (Object) null);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.canRead());
assertTrue(file0.isFile());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(0L, file0.length());
assertEquals(" in a comment0", file0.getName());
assertFalse(file0.isDirectory());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(0L, file0.getUsableSpace());
assertTrue(file0.exists());
assertEquals("/tmp", file0.getParent());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(6, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw(charArray0, 4, 2492);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 19
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test263() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
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.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
assertNotNull(pipedOutputStream0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)126;
byteArray0[1] = (byte)123;
byteArray0[2] = (byte) (-64);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 2337, (ObjectCodec) null, pipedOutputStream0, byteArray0, 407, true);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(407, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(2337, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)126, (byte)123, (byte) (-64)}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeRawValue());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertNotNull(tokenFilter0);
char[] charArray0 = new char[5];
charArray0[0] = 'z';
charArray0[1] = '@';
charArray0[2] = '1';
charArray0[3] = '1';
charArray0[4] = 'O';
// try {
uTF8JsonGenerator0.writeRaw(charArray0, 255, (-1));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test264() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
char[] charArray0 = new char[3];
charArray0[1] = '%';
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3320));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
boolean boolean0 = false;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-2736), (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 689, false);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals((-2736), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(689, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '%', 'O'}, charArray0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw(charArray0, (-1007), 0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test265() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
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(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
String string0 = "";
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, objectArray0.length);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
printStream0.println(14);
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
char char0 = ']';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-2736), (-3070));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, objectArray0.length);
assertEquals(19, charArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
BigDecimal bigDecimal0 = new BigDecimal(661.447);
assertEquals((byte) (-107), bigDecimal0.byteValue());
assertEquals((short)661, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals((byte) (-107), bigDecimal0.byteValue());
assertEquals((short)661, bigDecimal0.shortValue());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(47, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeFieldName("");
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(48, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeBoolean(false);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, file0.getTotalSpace());
assertEquals(0L, file0.getFreeSpace());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canRead());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertEquals(" in a comment0", file0.getName());
assertTrue(file0.canExecute());
assertTrue(file0.canWrite());
assertTrue(file0.isFile());
assertFalse(file0.isHidden());
assertEquals(0L, file0.getUsableSpace());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(54, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
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(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
Base64Variant base64Variant0 = null;
// try {
base64Variant0 = new Base64Variant("", "", true, 'z', 2056);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Base64Alphabet length must be exactly 64 (was 0)
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test266() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(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(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 99, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertNotNull(uTF8JsonGenerator0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext3);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)64;
byteArray0[1] = (byte)0;
IOContext iOContext4 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext4.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext4.getEncoding());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext4.equals((Object)iOContext2));
assertFalse(iOContext4.equals((Object)iOContext0));
assertFalse(iOContext4.equals((Object)iOContext3));
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext1, iOContext4);
assertNotSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext4, iOContext1);
assertNotSame(iOContext4, iOContext2);
assertNotSame(iOContext4, iOContext0);
assertNotSame(iOContext4, iOContext3);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext4);
byteArray0[2] = (byte)0;
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 2, (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)0, true);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals(0, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)64, (byte)0, (byte)0}, byteArray0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertNotNull(serializedString0);
uTF8JsonGenerator1.writeRaw('x');
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(uTF8JsonGenerator1.isClosed());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator1.getHighestEscapedChar());
assertEquals(1, uTF8JsonGenerator1.getOutputBuffered());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertEquals(2, uTF8JsonGenerator1.getFeatureMask());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(uTF8JsonGenerator1.equals((Object)uTF8JsonGenerator0));
assertEquals(3, byteArray0.length);
assertArrayEquals(new byte[] {(byte)120, (byte)0, (byte)0}, byteArray0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext1, iOContext4);
assertNotSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext2);
assertNotSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
uTF8JsonGenerator1.writeString("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
}
@Test(timeout = 4000)
public void test267() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertNotNull(serializedString0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
ByteBuffer byteBuffer0 = ByteBuffer.allocateDirect(57343);
assertEquals("java.nio.DirectByteBuffer[pos=0 lim=57343 cap=57343]", byteBuffer0.toString());
assertTrue(byteBuffer0.hasRemaining());
assertFalse(byteBuffer0.isReadOnly());
assertEquals(0, byteBuffer0.position());
assertEquals(57343, byteBuffer0.remaining());
assertEquals(57343, byteBuffer0.capacity());
assertEquals(57343, byteBuffer0.limit());
assertTrue(byteBuffer0.isDirect());
assertFalse(byteBuffer0.hasArray());
assertNotNull(byteBuffer0);
int int0 = serializedString1.putQuotedUTF8(byteBuffer0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertTrue(byteBuffer0.hasRemaining());
assertEquals("java.nio.DirectByteBuffer[pos=1 lim=57343 cap=57343]", byteBuffer0.toString());
assertFalse(byteBuffer0.isReadOnly());
assertEquals(1, byteBuffer0.position());
assertEquals(57343, byteBuffer0.capacity());
assertEquals(57342, byteBuffer0.remaining());
assertEquals(57343, byteBuffer0.limit());
assertTrue(byteBuffer0.isDirect());
assertFalse(byteBuffer0.hasArray());
assertFalse(serializedString1.equals((Object)serializedString0));
assertEquals(1, int0);
assertNotSame(serializedString1, serializedString0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(1, serializedString1.charLength());
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotSame(serializedString1, serializedString0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
char[] charArray0 = new char[8];
charArray0[0] = 'r';
charArray0[1] = '\'';
charArray0[2] = 'o';
charArray0[3] = 'm';
charArray0[4] = '~';
charArray0[5] = 'r';
charArray0[6] = '@';
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((byte)0, bigDecimal0.byteValue());
assertEquals((short)0, bigDecimal0.shortValue());
assertNotNull(bigDecimal0);
SerializedString serializedString2 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.getValue());
assertEquals(" ", serializedString2.toString());
assertFalse(serializedString2.equals((Object)serializedString0));
assertNotSame(serializedString2, serializedString0);
assertSame(serializedString2, serializedString1);
assertNotNull(serializedString2);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, serializedString2.charLength());
assertEquals(" ", serializedString2.getValue());
assertEquals(" ", serializedString2.toString());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(4, uTF8JsonGenerator0.getOutputBuffered());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(serializedString2.equals((Object)serializedString0));
assertNotSame(serializedString2, serializedString0);
assertSame(serializedString2, serializedString1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertEquals(16, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(11, serializedString0.charLength());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertFalse(serializedString0.equals((Object)serializedString2));
assertFalse(serializedString0.equals((Object)serializedString1));
assertNotSame(serializedString0, serializedString2);
assertNotSame(serializedString0, serializedString1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
}
@Test(timeout = 4000)
public void test268() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 99, (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeNull());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeRawValue());
assertNotNull(tokenFilter0);
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)64;
byteArray0[1] = (byte)0;
BigDecimal bigDecimal0 = BigDecimal.ZERO;
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertNotNull(bigDecimal0);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(99, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(3, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.isClosed());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((short)0, bigDecimal0.shortValue());
assertEquals((byte)0, bigDecimal0.byteValue());
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((char[]) null, 2, 11);
// 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 test269() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(0, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals("e/o=,L$?3bi", serializedString0.toString());
assertEquals("e/o=,L$?3bi", serializedString0.getValue());
assertEquals(11, serializedString0.charLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
byte[] byteArray0 = new byte[9];
UTF8JsonGenerator uTF8JsonGenerator1 = (UTF8JsonGenerator)uTF8JsonGenerator0.useDefaultPrettyPrinter();
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.canWriteObjectId());
assertFalse(uTF8JsonGenerator1.canWriteFormattedNumbers());
assertEquals(127, uTF8JsonGenerator1.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator1.canWriteTypeId());
assertFalse(uTF8JsonGenerator1.isClosed());
assertTrue(uTF8JsonGenerator1.canOmitFields());
assertEquals(13, uTF8JsonGenerator1.getOutputBuffered());
assertEquals(0, uTF8JsonGenerator1.getFormatFeatures());
assertFalse(uTF8JsonGenerator1.canWriteBinaryNatively());
assertEquals((-128), uTF8JsonGenerator1.getFeatureMask());
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(uTF8JsonGenerator1, uTF8JsonGenerator0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator1);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(byteArrayBuilder0);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(iOContext2);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
assertTrue(tokenFilter0.includeBinary());
assertTrue(tokenFilter0.includeNull());
assertTrue(tokenFilter0.includeRawValue());
assertEquals("TokenFilter.INCLUDE_ALL", tokenFilter0.toString());
assertNotNull(tokenFilter0);
BigInteger bigInteger0 = new BigInteger(byteArray0);
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotNull(bigInteger0);
double double0 = bigInteger0.doubleValue();
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertEquals(0.0, double0, 0.01);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(15, uTF8JsonGenerator0.getOutputBuffered());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
uTF8JsonGenerator0.writeNumber(bigInteger0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(127, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(17, uTF8JsonGenerator0.getOutputBuffered());
assertEquals((-128), uTF8JsonGenerator0.getFeatureMask());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals((byte)0, bigInteger0.byteValue());
assertEquals((short)0, bigInteger0.shortValue());
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertEquals(9, byteArray0.length);
assertArrayEquals(new byte[] {(byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0, (byte)0}, byteArray0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(uTF8JsonGenerator0, uTF8JsonGenerator1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
Base64Variant base64Variant0 = null;
// try {
base64Variant0 = new Base64Variant("", "write a raw (unencoded) value", false, '^', 894);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Base64Alphabet length must be exactly 64 (was 29)
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test270() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "");
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertNotNull(serializedString0);
int int0 = serializedString0.appendQuotedUTF8(byteArray0, 2);
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals((-1), int0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (byte)83, (ObjectCodec) null, mockPrintStream0, byteArray0, (-1979), false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getFreeSpace());
assertFalse(file0.isDirectory());
assertEquals(0L, file0.getTotalSpace());
assertTrue(file0.exists());
assertEquals(0L, file0.length());
assertEquals(1392409281320L, file0.lastModified());
assertTrue(file0.canExecute());
assertTrue(file0.isAbsolute());
assertTrue(file0.isFile());
assertTrue(file0.canRead());
assertTrue(file0.canWrite());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals("/tmp", file0.getParent());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals((-1979), uTF8JsonGenerator0.getOutputBuffered());
assertEquals(83, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString1.toString());
assertEquals(" ", serializedString1.getValue());
assertEquals(1, serializedString1.charLength());
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertSame(serializedString1, serializedString0);
assertNotNull(serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1979
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test271() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
char[] charArray0 = new char[3];
charArray0[1] = '%';
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
ObjectCodec objectCodec0 = null;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3320));
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArrayBuilder0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1354, false);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
assertFalse(uTF8JsonGenerator0.isClosed());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertEquals(2, uTF8JsonGenerator0.getFeatureMask());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertEquals(1354, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '%', 'O'}, charArray0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertNotNull(uTF8JsonGenerator0);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
assertNotNull(sequenceInputStream0);
IOContext iOContext1 = new IOContext(bufferRecycler0, sequenceInputStream0, true);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(3, charArray0.length);
assertArrayEquals(new char[] {'\u0000', '%', 'O'}, charArray0);
assertNotNull(serializedString0);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test272() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
File file0 = MockFile.createTempFile(" in a comment", "");
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertNotNull(file0);
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
assertNotNull(mockPrintStream0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(2, objectArray0.length);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertNotNull(printStream0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.length());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(383, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(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(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
assertNotNull(uTF8JsonGenerator0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)83}, byteArray0);
assertNotNull(serializedString0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertEquals(3L, file0.length());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(" ", serializedString0.toString());
assertEquals(" ", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
uTF8JsonGenerator0.writeUTF8String(byteArray0, 1, 0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(file0.isAbsolute());
assertTrue(file0.exists());
assertEquals(0L, file0.getTotalSpace());
assertEquals(1392409281320L, file0.lastModified());
assertFalse(file0.isDirectory());
assertTrue(file0.canWrite());
assertTrue(file0.canExecute());
assertEquals(0L, file0.getFreeSpace());
assertEquals(" in a comment0", file0.getName());
assertEquals(0L, file0.getUsableSpace());
assertEquals(6L, file0.length());
assertFalse(file0.isHidden());
assertTrue(file0.canRead());
assertEquals("/tmp", file0.getParent());
assertTrue(file0.isFile());
assertEquals("/tmp/ in a comment0", file0.toString());
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
assertFalse(uTF8JsonGenerator0.canWriteBinaryNatively());
assertEquals(55, uTF8JsonGenerator0.getFeatureMask());
assertTrue(uTF8JsonGenerator0.canOmitFields());
assertFalse(uTF8JsonGenerator0.isClosed());
assertEquals(0, uTF8JsonGenerator0.getHighestEscapedChar());
assertFalse(uTF8JsonGenerator0.canWriteFormattedNumbers());
assertFalse(uTF8JsonGenerator0.canWriteObjectId());
assertFalse(uTF8JsonGenerator0.canWriteTypeId());
assertEquals(0, uTF8JsonGenerator0.getFormatFeatures());
assertEquals(2, objectArray0.length);
assertEquals(1, byteArray0.length);
assertArrayEquals(new byte[] {(byte)34}, byteArray0);
assertSame(mockPrintStream0, printStream0);
assertSame(printStream0, mockPrintStream0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(55296, GeneratorBase.SURR1_FIRST);
assertEquals(56319, GeneratorBase.SURR1_LAST);
assertEquals(57343, GeneratorBase.SURR2_LAST);
assertEquals(56320, GeneratorBase.SURR2_FIRST);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, (-165), (-1392));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test273() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
serializedString0.asQuotedChars();
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)39;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)1;
byteArray0[4] = (byte)39;
byteArray0[5] = (byte)39;
// Undeclared exception!
// try {
uTF8JsonGenerator0._flushBuffer();
// 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 test274() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
ObjectCodec objectCodec0 = null;
OutputStream outputStream0 = null;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
boolean boolean0 = false;
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, true);
filteringGeneratorDelegate0.getCodec();
filteringGeneratorDelegate0.writeStartArray(56319);
// Undeclared exception!
// try {
uTF8JsonGenerator0.close();
// 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 test275() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
PipedInputStream pipedInputStream0 = new PipedInputStream(pipedOutputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, pipedInputStream0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
iOContext0.withEncoding(jsonEncoding0);
PipedOutputStream pipedOutputStream1 = new PipedOutputStream();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-3103), (ObjectCodec) null, pipedOutputStream0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
uTF8JsonGenerator0.disable(jsonGenerator_Feature0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
uTF8JsonGenerator0.writeString((char[]) null, 2, (-3));
uTF8JsonGenerator0.writeBoolean(true);
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
}
@Test(timeout = 4000)
public void test276() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
uTF8JsonGenerator0.writeNull();
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = '.';
charArray0[2] = '.';
charArray0[3] = 'o';
charArray0[4] = '.';
charArray0[5] = 'o';
charArray0[6] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 224, 0);
uTF8JsonGenerator0.writeNumber((short)49);
uTF8JsonGenerator0.writeStartArray();
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)6;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte) (-55);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
uTF8JsonGenerator0.writeRawValue((SerializableString) serializedString0);
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
}
@Test(timeout = 4000)
public void test277() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
File file0 = MockFile.createTempFile(" in a comment", "");
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-2736), (-3070));
BigDecimal bigDecimal0 = new BigDecimal(661.447);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
uTF8JsonGenerator0.writeFieldName("");
uTF8JsonGenerator0.writeBoolean(false);
assertEquals(54, uTF8JsonGenerator0.getOutputBuffered());
}
@Test(timeout = 4000)
public void test278() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
File file0 = MockFile.createTempFile(" in a comment", "");
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw((char[]) null, 14, 0);
BigDecimal bigDecimal0 = new BigDecimal((double) 1);
uTF8JsonGenerator0.writeNumber(bigDecimal0);
assertEquals(1, uTF8JsonGenerator0.getOutputBuffered());
}
@Test(timeout = 4000)
public void test279() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
String string0 = "2.7.7-SNAPSHOT";
File file0 = MockFile.createTempFile(" in a comment", "2.7.7-SNAPSHOT");
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
PrintStream printStream0 = mockPrintStream0.format("2.7.7-SNAPSHOT", objectArray0);
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)83;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 55, (ObjectCodec) null, printStream0, byteArray0, 383, false);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
IOContext iOContext1 = new IOContext(bufferRecycler0, " in a comment", false);
MockPrintStream mockPrintStream1 = new MockPrintStream(mockPrintStream0, false);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 57343, (ObjectCodec) null, mockPrintStream1, byteArray0, 2, false);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
mockPrintStream1.append((CharSequence) null, 0, 1);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawValue("No ObjectCodec defined for parser, needed for deserialization", 2, 55296);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test280() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[3];
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
ObjectCodec objectCodec0 = null;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3351));
boolean boolean0 = false;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1354, false);
int int0 = 2;
String string0 = "-5";
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawValue("-5", 1749, 1356);
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test281() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-156), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
SerializedString serializedString1 = new SerializedString("0123456789ABCDEF");
serializedString1.asUnquotedUTF8();
serializedString1.asQuotedUTF8();
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, true);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw("0123456789ABCDEF", 3, 56320);
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test282() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
IOContext iOContext1 = new IOContext(bufferRecycler0, "e/o=,L$?3bi", false);
char char0 = 'C';
char char1 = 'k';
uTF8JsonGenerator0.writeRaw('k');
uTF8JsonGenerator0.writeObjectFieldStart("");
uTF8JsonGenerator0.getOutputTarget();
Object object0 = new Object();
// try {
uTF8JsonGenerator0.writeObject((Object) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a null, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test283() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("*G:cNyv?i");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1194), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 69, 2, true);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(readerBasedJsonParser0, tokenFilter0, true, true);
filteringParserDelegate0.getCodec();
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 4190);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, (-1304), (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1262, true);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw("\"3_x(lI7p/%J3H~", 2, 0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test284() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
ObjectCodec objectCodec0 = null;
FileSystemHandling.shouldAllThrowIOExceptions();
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 120);
byte[] byteArray0 = new byte[2];
byte byte0 = (byte)99;
byteArray0[0] = (byte)99;
byteArray0[1] = (byte)46;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, byteArrayBuilder0, byteArray0, 5, false);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeNumber((-306.6F));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test285() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
String string0 = " in a comment";
File file0 = MockFile.createTempFile(" in a comment", "");
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
char[] charArray0 = new char[19];
charArray0[6] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
uTF8JsonGenerator0.writeRaw(charArray0, (-2736), (-3070));
BigDecimal bigDecimal0 = BigDecimal.ONE;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw(charArray0, 0, 56319);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 19
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test286() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
byte[] byteArray0 = new byte[6];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)126;
byte byte0 = (byte)123;
byteArray0[3] = (byte)123;
byteArray0[4] = (byte) (-34);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 34, (ObjectCodec) null, pipedOutputStream0, byteArray0, 50, false);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
char[] charArray0 = new char[5];
charArray0[0] = 'O';
charArray0[1] = '@';
charArray0[2] = '@';
charArray0[3] = '1';
charArray0[4] = 'z';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw(charArray0, (-1249), (int) (byte)126);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1249
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test287() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[3];
charArray0[1] = '%';
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
ObjectCodec objectCodec0 = null;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3320));
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1354, false);
Enumeration<InputStream> enumeration0 = (Enumeration<InputStream>) mock(Enumeration.class, new ViolatedAssumptionAnswer());
doReturn(false).when(enumeration0).hasMoreElements();
SequenceInputStream sequenceInputStream0 = new SequenceInputStream(enumeration0);
IOContext iOContext1 = new IOContext(bufferRecycler0, sequenceInputStream0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext1.withEncoding(jsonEncoding0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, true, false);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw("com.fasterxml.jackson.core.util.JsonGeneratorDelegate", 2, 3);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test288() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
int int0 = (-128);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
uTF8JsonGenerator0.writeNull();
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = '.';
charArray0[2] = '.';
charArray0[3] = 'o';
charArray0[4] = '.';
charArray0[5] = 'o';
charArray0[6] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 224, 0);
uTF8JsonGenerator0.writeNumber((short)49);
uTF8JsonGenerator0.writeStartArray();
SerializedString serializedString0 = new SerializedString("start an array");
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString0);
Base64Variant base64Variant0 = null;
// try {
base64Variant0 = new Base64Variant("start an array", "start an array", false, '.', 69);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Base64Alphabet length must be exactly 64 (was 14)
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test289() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)81;
byteArray0[1] = (byte)71;
byteArray0[2] = (byte)81;
byteArray0[3] = (byte)81;
byteArray0[4] = (byte)81;
byteArray0[5] = (byte)81;
byteArray0[6] = (byte)81;
byteArray0[7] = (byte)117;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 601, 0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test290() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-156), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
SerializedString serializedString1 = new SerializedString("0123456789ABCDEF");
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
byte[] byteArray0 = new byte[8];
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)1;
byteArray0[4] = (byte)1;
byteArray0[5] = (byte)1;
byteArray0[6] = (byte)1;
uTF8JsonGenerator0.writeUTF8String(byteArray0, (byte)1, 2);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, (-156), (byte)1);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -156
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test291() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
iOContext0.constructTextBuffer();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 1, (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
SerializedString serializedString1 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0._outputTail = 35;
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
char[] charArray0 = new char[10];
SerializedString serializedString2 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString2);
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
SerializedString serializedString3 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
SerializedString serializedString4 = new SerializedString("");
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString4);
BigInteger bigInteger0 = BigInteger.ZERO;
uTF8JsonGenerator0.writeNumber(bigInteger0);
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString4);
// try {
uTF8JsonGenerator0.writeFieldName((SerializableString) serializedString3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a field name, expecting a value
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test292() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[9];
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 3609);
IOContext iOContext1 = new IOContext(bufferRecycler0, uTF8JsonGenerator0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
iOContext2.withEncoding(jsonEncoding1);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8, (ObjectCodec) null, (OutputStream) null, byteArray0, 8, false);
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
uTF8JsonGenerator1.writeRaw((SerializableString) serializedString1);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeFieldName((SerializableString) serializedString0);
// 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 test293() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[3];
charArray0[1] = '%';
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3351));
IOContext iOContext1 = new IOContext(bufferRecycler0, byteArrayBuilder0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext3, 56320, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 3, true);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw((SerializableString) serializedString0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test294() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-2), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
boolean boolean0 = true;
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext0, true);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte) (-31);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, 1, (ObjectCodec) null, (OutputStream) null, byteArray0, 1658, true);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeRawValue((SerializableString) serializedString0);
// 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 test295() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, (byte[]) null);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
ByteBuffer byteBuffer0 = ByteBuffer.allocateDirect(57343);
serializedString1.putQuotedUTF8(byteBuffer0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
char[] charArray0 = new char[8];
charArray0[0] = 'r';
charArray0[1] = '\'';
charArray0[2] = 'o';
charArray0[3] = 'm';
charArray0[4] = 'v';
charArray0[5] = 'r';
charArray0[6] = '@';
BigDecimal bigDecimal0 = BigDecimal.ZERO;
uTF8JsonGenerator0.writeNumber(bigDecimal0);
charArray0[7] = 'y';
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString0);
// 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 test296() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
uTF8JsonGenerator0.writeNull();
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = '.';
charArray0[2] = '.';
charArray0[3] = 'o';
charArray0[4] = '.';
charArray0[5] = 'o';
charArray0[6] = 'o';
uTF8JsonGenerator0.writeString(charArray0, 224, 0);
uTF8JsonGenerator0.writeNumber((short)49);
uTF8JsonGenerator0.writeStartArray();
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)6;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte) (-55);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRawUTF8String(byteArray0, 65535, 79);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test297() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 16);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)28;
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)13;
byteArray0[3] = (byte)94;
byteArray0[4] = (byte)13;
byteArray0[5] = (byte)119;
byteArray0[6] = (byte)26;
byteArray0[7] = (byte) (-41);
byteArray0[8] = (byte)95;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, byteArrayBuilder0, byteArray0, (-1071), false);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw('[');
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1071
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test298() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 99, (ObjectCodec) null, (OutputStream) null);
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler1, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF8;
iOContext0.withEncoding(jsonEncoding1);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
iOContext0.withEncoding(jsonEncoding0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)64;
byteArray0[1] = (byte)0;
byteArray0[2] = (byte)0;
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 2, (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)0, true);
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
uTF8JsonGenerator1.writeRaw('x');
assertArrayEquals(new byte[] {(byte)120, (byte)0, (byte)0}, byteArray0);
}
@Test(timeout = 4000)
public void test299() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[3];
charArray0[1] = '%';
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3351));
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1354, false);
IOContext iOContext1 = new IOContext(bufferRecycler0, byteArrayBuilder0, false);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw('C');
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test300() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
iOContext0.constructTextBuffer();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
char char0 = 'y';
char char1 = 'r';
char char2 = '@';
char[] charArray0 = new char[8];
charArray0[0] = 'r';
charArray0[1] = '\'';
charArray0[2] = 'o';
uTF8JsonGenerator0.writeRaw('Y');
uTF8JsonGenerator0.writeObjectFieldStart("");
charArray0[3] = 'm';
charArray0[4] = 'v';
uTF8JsonGenerator0.getOutputTarget();
// try {
uTF8JsonGenerator0.writeObject((Object) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a null, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test301() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 99, (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)1;
int int0 = 125;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 125, (-11));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test302() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
uTF8JsonGenerator0.writeNull();
char char0 = 'o';
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = '.';
charArray0[2] = '.';
charArray0[3] = 'o';
charArray0[4] = '.';
charArray0[5] = 'o';
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)4;
uTF8JsonGenerator0.writeStartArray();
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 11, (byte)4);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 11
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test303() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
ByteBuffer byteBuffer0 = ByteBuffer.allocateDirect(57343);
serializedString1.putQuotedUTF8(byteBuffer0);
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
char[] charArray0 = new char[8];
charArray0[0] = 'r';
charArray0[1] = '\'';
charArray0[2] = 'o';
charArray0[3] = 'm';
charArray0[4] = 'v';
charArray0[5] = 'r';
charArray0[6] = '@';
charArray0[7] = 'y';
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
// Undeclared exception!
// try {
uTF8JsonGenerator0._writePPFieldName(serializedString0);
// 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 test304() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)39;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)1;
byteArray0[4] = (byte)39;
byteArray0[5] = (byte)39;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, (byte)1, (byte)39);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 9
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test305() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.withEncoding(jsonEncoding0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, pipedOutputStream0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonGenerator jsonGenerator0 = uTF8JsonGenerator0.disable(jsonGenerator_Feature0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
jsonGenerator0.writeString((char[]) null, 1, (-3));
uTF8JsonGenerator0.writeBoolean(false);
assertEquals(8, uTF8JsonGenerator0.getOutputBuffered());
}
@Test(timeout = 4000)
public void test306() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
iOContext0.constructTextBuffer();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
char char0 = 'y';
char char1 = 'r';
char char2 = '@';
char[] charArray0 = new char[8];
charArray0[0] = 'r';
charArray0[1] = '\'';
charArray0[2] = 'o';
uTF8JsonGenerator0.writeObjectFieldStart("");
charArray0[3] = 'm';
charArray0[4] = 'v';
uTF8JsonGenerator0.getOutputTarget();
// try {
uTF8JsonGenerator0.writeObject((Object) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Can not write a null, expecting field name
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test307() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 99, (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)1;
int int0 = 125;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 125, (-2));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test308() throws Throwable {
byte[] byteArray0 = new byte[0];
SerializedString serializedString0 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
SerializedString serializedString1 = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
BufferedOutputStream bufferedOutputStream0 = new BufferedOutputStream((OutputStream) null, 3055);
UTF8JsonGenerator uTF8JsonGenerator0 = null;
// try {
uTF8JsonGenerator0 = new UTF8JsonGenerator((IOContext) null, 3515, (ObjectCodec) null, (OutputStream) null);
// 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 test309() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
uTF8JsonGenerator0.writeNull();
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = '.';
charArray0[2] = '.';
charArray0[3] = 'o';
charArray0[4] = '.';
charArray0[5] = 'o';
charArray0[6] = 'o';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 1, 8000);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 7
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test310() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
PipedInputStream pipedInputStream0 = new PipedInputStream(pipedOutputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, pipedInputStream0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
PipedOutputStream pipedOutputStream1 = new PipedOutputStream();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 0, (ObjectCodec) null, pipedOutputStream0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
uTF8JsonGenerator0.disable(jsonGenerator_Feature0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
TokenFilter tokenFilter1 = tokenFilter0.includeProperty("Too few bytes available: missing ");
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter1, true, true);
filteringGeneratorDelegate0.getCodec();
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw("", 1, 0);
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test311() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3219, (ObjectCodec) null, (OutputStream) null);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String((byte[]) null, 110, (-601));
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// }
}
@Test(timeout = 4000)
public void test312() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte) (-64);
byteArray0[1] = (byte)83;
byteArray0[2] = (byte)126;
byteArray0[3] = (byte)123;
byteArray0[4] = (byte) (-34);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 34, (ObjectCodec) null, pipedOutputStream0, byteArray0, 50, false);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
filteringGeneratorDelegate0.getCodec();
// try {
filteringGeneratorDelegate0.writeStartArray((int) (byte)123);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Pipe not connected
// //
// verifyException("java.io.PipedOutputStream", e);
// }
}
@Test(timeout = 4000)
public void test313() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, (-128), (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)1, true);
// Undeclared exception!
// try {
uTF8JsonGenerator1.writeBoolean(false);
// 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 test314() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
uTF8JsonGenerator0.writeString((SerializableString) serializedString1);
char[] charArray0 = new char[8];
charArray0[0] = 'r';
charArray0[1] = '\'';
charArray0[2] = 'o';
charArray0[3] = 'm';
charArray0[4] = 'v';
charArray0[5] = 'r';
charArray0[6] = '@';
charArray0[7] = 'y';
uTF8JsonGenerator0.writeString(charArray0, 0, 1);
assertEquals(7, uTF8JsonGenerator0.getOutputBuffered());
}
@Test(timeout = 4000)
public void test315() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)39;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 115, (-2));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test316() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)39;
byteArray0[1] = (byte)1;
byteArray0[2] = (byte)1;
byteArray0[3] = (byte)1;
byteArray0[4] = (byte)39;
byteArray0[5] = (byte)39;
byteArray0[6] = (byte)1;
byteArray0[7] = (byte)1;
byteArray0[8] = (byte)1;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 81, 1977);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 81
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test317() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
String string0 = " in a comment";
String string1 = "";
File file0 = MockFile.createTempFile(" in a comment", "");
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 943, (ObjectCodec) null, mockPrintStream0);
char[] charArray0 = new char[6];
charArray0[0] = '_';
charArray0[1] = 'm';
charArray0[2] = 'r';
charArray0[3] = 'y';
charArray0[4] = 'y';
charArray0[5] = 'Q';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, 0, 943);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 6
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test318() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
PipedInputStream pipedInputStream0 = new PipedInputStream(pipedOutputStream0);
IOContext iOContext0 = new IOContext(bufferRecycler0, pipedInputStream0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
PipedOutputStream pipedOutputStream1 = new PipedOutputStream();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 0, (ObjectCodec) null, pipedOutputStream0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
uTF8JsonGenerator0.disable(jsonGenerator_Feature0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
TokenFilter tokenFilter1 = tokenFilter0.includeProperty("Too few bytes available: missing ");
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter1, true, true);
filteringGeneratorDelegate0.getCodec();
uTF8JsonGenerator0.writeRaw("l", 1, 0);
// try {
uTF8JsonGenerator0.writeEndArray();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an ARRAY but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test319() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-75);
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
uTF8JsonGenerator0.getOutputTarget();
assertEquals(13, uTF8JsonGenerator0.getOutputBuffered());
System.setCurrentTimeMillis(19L);
// try {
uTF8JsonGenerator0.writeEndObject();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an object but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test320() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
uTF8JsonGenerator0.writeNull();
// Undeclared exception!
// try {
uTF8JsonGenerator0._verifyPrettyValueWrite("e/o=,L$?3bi", 51);
// fail("Expecting exception: RuntimeException");
// } catch(RuntimeException e) {
// //
// // Internal error: this code path should never get executed
// //
// verifyException("com.fasterxml.jackson.core.util.VersionUtil", e);
// }
}
@Test(timeout = 4000)
public void test321() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.withEncoding(jsonEncoding0);
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, pipedOutputStream0);
JsonGenerator.Feature jsonGenerator_Feature0 = JsonGenerator.Feature.IGNORE_UNKNOWN;
JsonGenerator jsonGenerator0 = uTF8JsonGenerator0.disable(jsonGenerator_Feature0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
TokenFilter tokenFilter1 = tokenFilter0.includeProperty("Too few bytes available: missing ");
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(jsonGenerator0, tokenFilter1, false, false);
filteringGeneratorDelegate0.getCodec();
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte)0;
uTF8JsonGenerator0.writeRaw("*h7HWcW5/kw{$_J3@y", 2, 3);
// try {
uTF8JsonGenerator0.writeEndArray();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current context not an ARRAY but ROOT
// //
// verifyException("com.fasterxml.jackson.core.JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test322() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
String string0 = "e/o=,L$?3bi";
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)39;
byteArray0[1] = (byte)1;
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
iOContext0.withEncoding(jsonEncoding0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
TokenFilter tokenFilter1 = tokenFilter0.filterStartArray();
boolean boolean0 = true;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter1, true, true);
filteringGeneratorDelegate0.getCodec();
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext1, 8000, (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString1 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
filteringGeneratorDelegate0.setRootValueSeparator(serializedString1);
uTF8JsonGenerator1._flushBuffer();
BigInteger bigInteger0 = new BigInteger(byteArray0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
uTF8JsonGenerator0.writeNumber(bigInteger0);
char char0 = 'L';
Base64Variant base64Variant0 = null;
// try {
base64Variant0 = new Base64Variant("", "E&M[\"GC?:SW|YJ(", true, 'L', 8000);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Base64Alphabet length must be exactly 64 (was 15)
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test323() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[3];
charArray0[0] = 'x';
charArray0[1] = '%';
charArray0[2] = 'O';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocConcatBuffer();
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, (-3351));
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 2, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 1354, false);
Object object0 = uTF8JsonGenerator0.getOutputTarget();
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(uTF8JsonGenerator0, tokenFilter0, false, false);
filteringGeneratorDelegate0.getCodec();
UTF8JsonGenerator uTF8JsonGenerator1 = new UTF8JsonGenerator(iOContext2, 3302, (ObjectCodec) null, byteArrayBuilder0);
SerializedString serializedString0 = (SerializedString)uTF8JsonGenerator0._rootValueSeparator;
filteringGeneratorDelegate0.setRootValueSeparator(serializedString0);
uTF8JsonGenerator1._flushBuffer();
BigInteger bigInteger0 = null;
// try {
bigInteger0 = new BigInteger(byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: NumberFormatException");
// } catch(NumberFormatException e) {
// //
// // Zero length BigInteger
// //
// verifyException("java.math.BigInteger", e);
// }
}
@Test(timeout = 4000)
public void test324() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 1);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 3, (ObjectCodec) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES, 13, false);
uTF8JsonGenerator0.getOutputTarget();
boolean boolean1 = false;
SequenceInputStream sequenceInputStream0 = null;
// try {
sequenceInputStream0 = new SequenceInputStream((InputStream) null, (InputStream) null);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.SequenceInputStream", e);
// }
}
@Test(timeout = 4000)
public void test325() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)1;
byteArray0[1] = (byte)39;
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeUTF8String(byteArray0, 115, (-2));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test326() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-128), (ObjectCodec) null, (OutputStream) null);
SerializedString serializedString0 = new SerializedString("e/o=,L$?3bi");
uTF8JsonGenerator0.writeString((SerializableString) serializedString0);
char[] charArray0 = new char[9];
charArray0[0] = '!';
charArray0[1] = 'K';
charArray0[2] = 'y';
charArray0[3] = 'r';
charArray0[4] = '@';
charArray0[5] = 'Q';
charArray0[6] = '.';
charArray0[7] = 'o';
charArray0[8] = 'm';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeString(charArray0, (-2354), 3);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -2354
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test327() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
BufferedOutputStream bufferedOutputStream0 = new BufferedOutputStream((OutputStream) null, 3);
MockPrintStream mockPrintStream0 = new MockPrintStream(bufferedOutputStream0);
iOContext1.allocWriteEncodingBuffer();
iOContext1.allocReadIOBuffer();
bufferedOutputStream0.write(3);
UTF8JsonGenerator uTF8JsonGenerator0 = null;
// try {
uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 69, (ObjectCodec) null, mockPrintStream0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test328() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
File file0 = MockFile.createTempFile(" in a comment", "");
MockPrintStream mockPrintStream0 = new MockPrintStream(file0);
Object[] objectArray0 = new Object[2];
objectArray0[0] = (Object) bufferRecycler0;
objectArray0[1] = (Object) null;
PrintStream printStream0 = mockPrintStream0.format("", objectArray0);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, 0, (ObjectCodec) null, printStream0);
char[] charArray0 = new char[5];
charArray0[0] = '|';
charArray0[1] = ']';
charArray0[2] = 'z';
charArray0[3] = '3';
charArray0[4] = 'O';
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeRaw(charArray0, 1, 2492);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 5
// //
// verifyException("com.fasterxml.jackson.core.json.UTF8JsonGenerator", e);
// }
}
@Test(timeout = 4000)
public void test329() throws Throwable {
String string0 = "tY'z^ de)";
IOContext iOContext0 = new IOContext((BufferRecycler) null, "tY'z^ de)", false);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)0;
byteArray0[1] = (byte) (-57);
byte byte0 = (byte)75;
byteArray0[2] = (byte)75;
byteArray0[3] = (byte) (-51);
byteArray0[4] = (byte) (-61);
byteArray0[5] = (byte)0;
byteArray0[6] = (byte) (-31);
byteArray0[7] = (byte)58;
byteArray0[8] = (byte)91;
UTF8JsonGenerator uTF8JsonGenerator0 = null;
// try {
uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-23), (ObjectCodec) null, (OutputStream) null, byteArray0, (byte)75, false);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test330() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
WriterBasedJsonGenerator writerBasedJsonGenerator0 = new WriterBasedJsonGenerator(iOContext0, 0, (ObjectCodec) null, (Writer) null);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringGeneratorDelegate filteringGeneratorDelegate0 = new FilteringGeneratorDelegate(writerBasedJsonGenerator0, tokenFilter0, true, false);
filteringGeneratorDelegate0.getCodec();
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)18;
byteArray0[1] = (byte)108;
byteArray0[2] = (byte)0;
byteArray0[3] = (byte)83;
byteArray0[4] = (byte)110;
UTF8JsonGenerator uTF8JsonGenerator0 = null;
// try {
uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext0, (-3209), (ObjectCodec) null, (OutputStream) null, byteArray0, 2, false);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test331() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
PipedInputStream pipedInputStream0 = new PipedInputStream(16);
BufferedInputStream bufferedInputStream0 = new BufferedInputStream(pipedInputStream0, 255);
ByteQuadsCanonicalizer byteQuadsCanonicalizer0 = ByteQuadsCanonicalizer.createRoot();
byte[] byteArray0 = new byte[1];
byteArray0[0] = (byte) (-80);
UTF8StreamJsonParser uTF8StreamJsonParser0 = new UTF8StreamJsonParser(iOContext1, 55296, bufferedInputStream0, (ObjectCodec) null, byteQuadsCanonicalizer0, byteArray0, 0, (-3390), false);
TokenFilter tokenFilter0 = TokenFilter.INCLUDE_ALL;
FilteringParserDelegate filteringParserDelegate0 = new FilteringParserDelegate(uTF8StreamJsonParser0, tokenFilter0, false, false);
filteringParserDelegate0.getCodec();
PipedOutputStream pipedOutputStream0 = new PipedOutputStream();
byte[] byteArray1 = new byte[6];
byteArray1[0] = (byte) (-80);
byteArray1[1] = (byte) (-80);
byteArray1[2] = (byte) (-80);
byteArray1[3] = (byte) (-80);
byteArray1[4] = (byte) (-80);
byteArray1[5] = (byte) (-80);
UTF8JsonGenerator uTF8JsonGenerator0 = new UTF8JsonGenerator(iOContext1, 1, (ObjectCodec) null, pipedOutputStream0, byteArray1, (byte) (-80), false);
// Undeclared exception!
// try {
uTF8JsonGenerator0.writeBoolean(false);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
}
|
[
"[email protected]"
] | |
cc51c4dfa70c0412fe458217990d9fc61693851a
|
a151a881866527ad745c952922e091a80bf89e21
|
/java/src/main/java/com/fleetmgr/sdk/client/event/output/facade/ChannelsClosing.java
|
9957c43c01f6f2e008569f860f61cd1e008eed45
|
[
"MIT"
] |
permissive
|
nawbar23/fleetmgr
|
a052715f7ed71f5a45307e1db66a6aa639b3b221
|
e5f93877fa373841845941dacf37cfcd4364f69c
|
refs/heads/master
| 2020-04-08T20:56:57.246361 | 2019-01-11T18:17:27 | 2019-01-11T18:17:27 | 159,722,398 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 670 |
java
|
package com.fleetmgr.sdk.client.event.output.facade;
import com.fleetmgr.sdk.client.traffic.Channel;
import java.util.Collection;
/**
* Created by: Bartosz Nawrot
* Date: 18.09.2018
* Description:
*/
public class ChannelsClosing extends FacadeEvent {
private Collection<Channel> channels;
public ChannelsClosing(Collection<Channel> channels) {
super(Type.CHANNELS_CLOSING);
this.channels = channels;
}
public Collection<Channel> getChannels() {
return channels;
}
@Override
public String toString() {
return "ChannelsClosing{" +
"channels=" + channels +
'}';
}
}
|
[
"[email protected]"
] | |
f5052731c4a92b87cb0c6f8ec389cf24b8ae2d3e
|
99d25db9695cd625590e730153c9f483ba82371a
|
/threadTest.java
|
8bfe23e54832cb95dc2d0721008ce0334efc2c4f
|
[] |
no_license
|
alifsabrani/maze-escape
|
943a643dc4313f8cd1c2e7bc2365a73b594bbb2d
|
102766742c25423338372ea2a2239b81f978cce0
|
refs/heads/master
| 2020-12-13T02:15:12.177503 | 2020-01-16T09:48:44 | 2020-01-16T09:48:44 | 234,285,671 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 103 |
java
|
public class threadTest implements Runnable{
@Override
public void run(){
View v = new View();
}
}
|
[
"[email protected]"
] | |
da1ab7b2ba12f279f96b842b03adf3edced26bc4
|
9c226ff7d8b5b58d3201e8237ab6ab72a24bf46e
|
/src/main/java/whscheduler/model/ATStateModel.java
|
07305f1619135100377fb7a2c420359ee6235501
|
[] |
no_license
|
moshhud/whscheduler
|
6da91f2d77e0284de34da5a2263519149efef09c
|
150483a5ae2ed56629e09aca08bb5532bad57350
|
refs/heads/master
| 2022-12-01T00:12:53.226586 | 2019-08-27T09:54:28 | 2019-08-27T09:54:28 | 204,673,438 | 0 | 0 | null | 2022-11-24T06:19:24 | 2019-08-27T09:55:32 |
Java
|
UTF-8
|
Java
| false | false | 1,016 |
java
|
package whscheduler.model;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "at_state")
public class ATStateModel implements Serializable{
private static final long serialVersionUID = 1L;
@Id
@Column(name = "stID")
private long ID;
@Column(name = "stDurationInMillis")
private long durationInMillis;
public ATStateModel() {
}
public ATStateModel(int iD, long durationInMillis) {
ID = iD;
this.durationInMillis = durationInMillis;
}
public long getID() {
return ID;
}
public void setID(long iD) {
ID = iD;
}
public long getDurationInMillis() {
return durationInMillis;
}
public void setDurationInMillis(long durationInMillis) {
this.durationInMillis = durationInMillis;
}
@Override
public String toString() {
return "ATStateModel [ID=" + ID + ", durationInMillis=" + durationInMillis + "]";
}
}
|
[
"[email protected]"
] | |
ec2fe8e08866f758b98afa7ae6cafb644167bd4a
|
7d7f7a4949ce0cbfc4fdacf7f0c620ec911b7bb8
|
/marshalling-with-spring-boot/src/main/java/org/fantastic/PersonalShoppersApp.java
|
a04f6c39e4041181dce33d03c6e4b07e6c480c32
|
[] |
no_license
|
karesti/protobuf-marshalling-guide
|
a4bfa66440c0efe5129df74d2375bbf8f599a476
|
d0fe840fe472220448926f6e81b6a8be74089307
|
refs/heads/main
| 2023-04-06T07:57:06.896502 | 2021-04-13T15:06:48 | 2021-04-13T15:06:48 | 341,314,677 | 2 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 513 |
java
|
package org.fantastic;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableCaching
@EnableScheduling
public class PersonalShoppersApp {
public static void main(String... args) {
new SpringApplicationBuilder().sources(PersonalShoppersApp.class).run(args);
}
}
|
[
"[email protected]"
] | |
34cd1c3dcea9b2ea614c17ade906c61b2cdb9399
|
8fac382b08d87f34dd52791ec1faaae046cbd3de
|
/src/com/karnecki/blazej/animals/Tiger.java
|
4fb50e98a78e29cd3533221ae5b64d6f6ec89b10
|
[] |
no_license
|
zamwon/Zoo
|
323994e5a9872e547ab84b889a42c651efd8ec41
|
a983c79ad59f8b9fa0c01891b3f2aa8a20c3b310
|
refs/heads/master
| 2022-12-02T00:14:21.767939 | 2020-08-18T10:00:37 | 2020-08-18T10:00:37 | 288,419,503 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,070 |
java
|
package com.karnecki.blazej.animals;
public class Tiger extends Animal implements Cat {
private static final int MIN_WEIGHT = 10;
private static final int MAX_WEIGHT = 400;
private static final int MAX_AGE = 15;
private static final int MIN_AGE = 1;
private static final String ILLEGAL_NAME = "Invalid name for tiger, name cannot be null or blank";
private static final String ILLEGAL_WEIGHT = "Invalid tiger weight, weight cannot be lower then 10 kg and higer than 400 kg";
private static final String ILLEGAL_AGE = "Invalid tiger age, age cannot be lower then 1 year and higer than 15 years";
Tiger(TigerBuilder builder) {
this.name = builder.name;
this.age = builder.age;
this.weight = builder.weight;
}
public static class TigerBuilder extends Animal implements Cat {
public TigerBuilder setName(String name) throws IllegalAnimalNameException {
if (name == null || name.isEmpty()) {
throw new IllegalAnimalNameException((ILLEGAL_NAME));
} else {
this.name = name;
return this;
}
}
public TigerBuilder setAge(int age) throws IllegalAnimalAgeException {
if (age < MIN_AGE || age > MAX_AGE) {
throw new IllegalAnimalAgeException((ILLEGAL_AGE));
} else {
this.age = age;
return this;
}
}
public TigerBuilder setWeight(double weight) throws IllegalAnimalWeightException {
if (weight < MIN_WEIGHT || weight > MAX_WEIGHT) {
throw new IllegalAnimalWeightException((ILLEGAL_WEIGHT));
} else {
this.weight = weight;
return this;
}
}
public Tiger build() {
return new Tiger(this);
}
}
@Override
public String toString() {
return "Tiger -> " +
"name='" + name + '\'' +
", age=" + age +
", weight=" + weight;
}
}
|
[
"[email protected]"
] | |
779e4e02e392aac3f1947e213e2fdcd52811343c
|
f65b49b3787babcf8daf2f8d43df2b222c2f72d1
|
/app/src/main/java/com/iiysoftware/academy/Models/Date.java
|
2bba23fabe04db2b2f7c0244324820daa959a66b
|
[] |
no_license
|
jonathanjohn47/akal_academy_admin
|
a9bc4c4d0c8ad266109cdb7adb62f37c12ad272d
|
5ee1b46b0761e0948e1befe83739f5a8fe28a275
|
refs/heads/master
| 2020-12-27T03:51:21.492640 | 2020-02-02T10:29:40 | 2020-02-02T10:29:40 | 237,754,112 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 310 |
java
|
package com.iiysoftware.academy.Models;
public class Date {
private String date;
public Date(){
}
public Date(String date) {
this.date = date;
}
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
}
|
[
"[email protected]"
] | |
fe1cb4de961bd5c0c42de93143f882fe8d13c8bb
|
7d5ea57e73282c77fa9c7e8281109df00277c7eb
|
/zal/zaliczenie/src/main/java/com/example/zaliczenie/User.java
|
99d343cefe43483dcae23eed77fee7647cd91b60
|
[
"MIT"
] |
permissive
|
MadejaMaciej/java
|
1774470917b86829afd672d3849987b9ebbc40aa
|
234b6eedf4cc1e2547418cd9f3664201d76336bc
|
refs/heads/main
| 2023-06-17T17:45:05.558440 | 2021-07-20T10:02:01 | 2021-07-20T10:02:01 | 370,746,018 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,488 |
java
|
package com.example.zaliczenie;
import java.time.LocalDateTime;
import java.util.ArrayList;
import org.springframework.data.annotation.Id;
public class User {
@Id
private String id;
private String username;
private String email;
private String password;
private ArrayList<String> viewers = new ArrayList<>();
private ArrayList<String> posts = new ArrayList<>();
private ArrayList<LocalDateTime> timestamp = new ArrayList<>();
public void setUser(String uname, String mail, String pass) {
this.username = uname;
this.email = mail;
this.password = pass;
this.viewers.add(mail);
}
public void addViewer(String viewer){
viewers.add(viewer);
}
public void addPost(String post){
posts.add(post);
}
public void addTimestamp(){
timestamp.add(java.time.LocalDateTime.now());
}
public ArrayList<String> getPosts(){
return posts;
}
public ArrayList<LocalDateTime> getTimes(){
return timestamp;
}
public ArrayList<String> getViewers(){
return viewers;
}
public String getUsername(){
return username;
}
public String getEmail(){
return email;
}
public String getPassword(){
return password;
}
@Override
public String toString() {
return String.format(
"User[id=%s, username='%s', email='%s', password='%s']",
id, username, email, password);
}
}
|
[
"[email protected]"
] | |
e711e6bf8d9f2a5feddba9164e217ea51e355b84
|
233e63710e871ef841ff3bc44d3660a0c8f8564d
|
/trunk/gameserver/src/gameserver/dataholders/loadingutils/XmlDataLoader.java
|
b796f75ad5e1f53385bf50ff1a878a82e82fb2a1
|
[] |
no_license
|
Wankers/Project
|
733b6a4aa631a18d28a1b5ba914c02eb34a9f4f6
|
da6db42f127d5970522038971a8bebb76baa595d
|
refs/heads/master
| 2016-09-06T10:46:13.768097 | 2012-08-01T23:19:49 | 2012-08-01T23:19:49 | null | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 4,495 |
java
|
/*
* This file is part of Aion Extreme Emulator <aion-core.net>.
*
* Aion Extreme Emulator is a free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Aion Extreme Emulator is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Aion Extreme Emulator. If not, see <http://www.gnu.org/licenses/>.
*/
package gameserver.dataholders.loadingutils;
import gameserver.dataholders.StaticData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;
import javax.xml.XMLConstants;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Unmarshaller;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import java.io.File;
import java.io.FileReader;
/**
* This class is responsible for loading xml files. It uses JAXB to do the job.<br>
* In addition, it uses @{link {@link XmlMerger} to create input file from all xml files.
*
* @author Luno
*/
public class XmlDataLoader {
private static final Logger log = LoggerFactory.getLogger(XmlDataLoader.class);
/** File containing xml schema declaration */
private final static String XML_SCHEMA_FILE = "./data/static_data/static_data.xsd";
private static final String CACHE_DIRECTORY = "./cache/";
private static final String CACHE_XML_FILE = "./cache/static_data.xml";
private static final String MAIN_XML_FILE = "./data/static_data/static_data.xml";
public static final XmlDataLoader getInstance() {
return SingletonHolder.instance;
}
private XmlDataLoader() {
}
/**
* Creates {@link StaticData} object based on xml files, starting from static_data.xml
*
* @return StaticData object, containing all game data defined in xml files
*/
public StaticData loadStaticData() {
makeCacheDirectory();
File cachedXml = new File(CACHE_XML_FILE);
File cleanMainXml = new File(MAIN_XML_FILE);
mergeXmlFiles(cachedXml, cleanMainXml);
try {
JAXBContext jc = JAXBContext.newInstance(StaticData.class);
Unmarshaller un = jc.createUnmarshaller();
un.setEventHandler(new XmlValidationHandler());
un.setSchema(getSchema());
return (StaticData) un.unmarshal(new FileReader(CACHE_XML_FILE));
}
/*
catch (IllegalAnnotationsException e) {
log.error("Error while loading static data", e);
throw new Error("Error while loading static data", e);
}
catch (FileNotFoundException e) {
log.error("Error while loading static data", e);
throw new Error("Error while loading static data", e);
}
catch (JAXBException e) {
log.error("Error while loading static data", e);
throw new Error("Error while loading static data", e);
}*/
catch (Exception e) {
return null;
}
}
/**
* Creates and returns {@link Schema} object representing xml schema of xml files
*
* @return a Schema object.
*/
private Schema getSchema() {
Schema schema = null;
SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
try {
schema = sf.newSchema(new File(XML_SCHEMA_FILE));
}
catch (SAXException saxe) {
log.error("Error while getting schema", saxe);
throw new Error("Error while getting schema", saxe);
}
return schema;
}
/** Creates directory for cache files if it doesn't already exist */
private void makeCacheDirectory() {
File cacheDir = new File(CACHE_DIRECTORY);
if (!cacheDir.exists())
cacheDir.mkdir();
}
/**
* Merges xml files(if are newer than cache file) and puts output to cache file.
*
* @see XmlMerger
* @param cachedXml
* @param cleanMainXml
* @throws Error
* is thrown if some problem occured.
*/
private void mergeXmlFiles(File cachedXml, File cleanMainXml) throws Error {
XmlMerger merger = new XmlMerger(cleanMainXml, cachedXml);
try {
merger.process();
}
catch (Exception e) {
log.error("Error while merging xml files", e);
throw new Error("Error while merging xml files", e);
}
}
@SuppressWarnings("synthetic-access")
private static class SingletonHolder {
protected static final XmlDataLoader instance = new XmlDataLoader();
}
}
|
[
"sylvanodu14gmail.com"
] |
sylvanodu14gmail.com
|
c5e507bb97f2f3848ef392f8dceafc1553bd4ee7
|
c03454a269d6d60e3addfb4b3bdda909de9ea0b3
|
/TDD-COMP3004/TDD-COMP3004/src/test/server/TestConcludesEndAttackDoesntHit.java
|
60bedaffbb09939a814968eb214c9f7c75cb51bd
|
[] |
no_license
|
teestunna/TDD-GAME
|
066581bff1b05d3b0d6e87d0c3876f113e415f31
|
bcd439493d45953155cbd5f4659dd450b2e856b2
|
refs/heads/master
| 2020-07-30T16:10:27.356634 | 2018-08-03T03:02:30 | 2018-08-03T03:02:30 | 73,626,583 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 938 |
java
|
package test.server;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import server.Engine;
import static org.junit.Assert.*;
public class TestConcludesEndAttackDoesntHit {
Engine eng;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
}
@Before
public void setUp() throws Exception {
eng = new Engine();
}
@After
public void tearDown() throws Exception {
eng = null;
}
@Test
public void testConcludeEndAttackDoesntHit() {
int rollNumber = 1;
String attackType = eng.isEndAttackValid(eng.attackMechanism[0], rollNumber);
String defenceType = "DODGE";
System.out.println(attackType);
assertTrue("Should not hit",eng.ifConcludedFinalEndAttackDoesntHit(attackType,defenceType));
}
}
|
[
"[email protected]"
] | |
6bf0ccf1fc83be356d91a84690f4bccfac2b2b33
|
feb097cf85800f5b5581e1ea2d5d05b4696750e3
|
/src/main/java/alex/controller/EncodingFilter.java
|
c9edcab096e0de1f4780072547479e028bae0aeb
|
[
"MIT"
] |
permissive
|
AlexielArdilla/Gestor-Web-Aerolineas-UNPAZ
|
f761b4997f5d395788225a5a0bd884e89af6664d
|
9fef9090dbcad528f3c3689f4e6b5771ac2e42de
|
refs/heads/master
| 2023-07-15T13:32:41.159448 | 2023-06-27T10:46:59 | 2023-06-27T10:46:59 | 163,897,153 | 1 | 1 |
MIT
| 2022-12-16T11:06:24 | 2019-01-02T22:43:25 |
Java
|
UTF-8
|
Java
| false | false | 861 |
java
|
package alex.controller;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class EncodingFilter implements Filter {
private String encoding = "utf-8";
@Override
public void doFilter(ServletRequest request,
ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
request.setCharacterEncoding(encoding);
filterChain.doFilter(request, response);
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
String encodingParam = filterConfig.getInitParameter("encoding");
if (encodingParam != null) {
encoding = encodingParam;
}
}
public void destroy() {
// nothing todo
}
}
|
[
"[email protected]"
] | |
62c5fe3c0d16da6d3a5abe9f2fdbb2bf1601f4eb
|
7ff78a7b19d7bb3dd5b4e563308553d46a47d5ef
|
/src/main/java/common/toolkit/java/util/io/NetUtil.java
|
1091b6938bde2844d049e19fbefef687c68f5938
|
[] |
no_license
|
yueny/common-toolkit
|
8b728284bfc837e8ed91ebbd73da96fac5c8f701
|
f5589f92a1596840370df24d3a8d9be4d3b4fd1c
|
refs/heads/master
| 2020-12-24T06:36:16.524546 | 2016-11-13T08:45:34 | 2016-11-13T08:45:34 | 73,470,662 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 9,245 |
java
|
package common.toolkit.java.util.io;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.URI;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpConnectionManagerParams;
import org.apache.commons.httpclient.params.HttpMethodParams;
import common.toolkit.java.constant.EmptyObjectConstant;
import common.toolkit.java.constant.RegExpConstant;
import common.toolkit.java.constant.SymbolConstant;
import common.toolkit.java.util.StringUtil;
import common.toolkit.java.util.collection.CollectionUtil;
import common.toolkit.java.util.number.IntegerUtil;
/**
* 绫昏鏄� 缃戠粶鏈哄叧宸ュ叿绫�
* @author 閾舵椂 [email protected]
*/
public class NetUtil {
public static final Pattern PATTERN_OF_IP = Pattern.compile( RegExpConstant.REG_EXP_OF_IP );
public static final int DEFAULT_CONNECTION_TIMEOUT = 3000;
/**
* 妫�祴鏄惁鏄悎娉曠殑绔彛.
* @param int port 绔彛
* @return boolean 鏄惁鏄悎娉曠鍙�
*/
public static boolean isLegalPort( int port ) {
if ( port <= 0 || port > 65535 ) {
return false;
}
return true;
}
/**
* 妫�祴鏄惁鏄悎娉曠殑绔彛.
* @param String port 绔彛
* @return boolean 鏄惁鏄悎娉曠鍙�
*/
public static boolean isLegalPort( String port ) {
try {
return isLegalPort( Integer.parseInt( port ) );
} catch ( NumberFormatException e ) {
return false;
}
}
/**
* 妫�祴鏄惁鏄悎娉曠殑IP.
* @param String ip IP
* @return boolean 鏄惁鏄悎娉旾P
*/
public static boolean isLegalIP( String ip ) {
Matcher match = PATTERN_OF_IP.matcher( ip );
return match.matches();
}
/**
* 妫�煡鏈哄櫒鏄惁寮�惎鎸囧畾绔彛
* @param hostIp 鏈哄櫒ip
* @param port 鏈哄櫒port
* @return 鏄惁寮�惎
*/
public static boolean isHostOpenPort( String hostIp, int port ) throws Exception {
if ( StringUtil.isBlank( hostIp ) ) {
return false;
}
InetAddress address = InetAddress.getByName( hostIp );
if ( !address.isReachable( 2000 ) ) {
throw new Exception( "Can't connect host in 2000 ms: " + hostIp );
}
Socket socket = null;
try {
socket = new Socket( hostIp, port );
return true;
} catch ( UnknownHostException e ) {
throw new Exception( "UnknownHost: " + hostIp );
} catch ( IOException e ) {
return false;
} finally {
if ( null != socket )
socket.close();
}
}
public static String getContentOfUrl( String url, int connectionTimeout ) throws HttpException, IOException {
connectionTimeout = IntegerUtil.defaultIfZero( connectionTimeout, DEFAULT_CONNECTION_TIMEOUT );
// 鏋勯�HttpClient鐨勫疄渚�
HttpClient httpClient = new HttpClient();
// 鍒涘缓GET鏂规硶鐨勫疄渚�
GetMethod getMethod = new GetMethod( url );
// 浣跨敤绯荤粺鎻愪緵鐨勯粯璁ょ殑鎭㈠绛栫暐
getMethod.getParams().setParameter( HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler() );
HttpConnectionManagerParams managerParams = httpClient.getHttpConnectionManager().getParams();
// 璁剧疆杩炴帴瓒呮椂鏃堕棿(鍗曚綅姣)
managerParams.setConnectionTimeout( connectionTimeout );
// 璁剧疆璇绘暟鎹秴鏃舵椂闂�鍗曚綅姣)
managerParams.setSoTimeout( 60000 );
try {
// 鎵цgetMethod
int statusCode = httpClient.executeMethod( getMethod );
if ( statusCode != HttpStatus.SC_OK ) {
System.err.println( "Method failed: " + getMethod.getStatusLine() );
}
return IOUtil.convertInputStream2String( getMethod.getResponseBodyAsStream(), getMethod.getResponseCharSet() );
} finally {
// 閲婃斁杩炴帴
getMethod.releaseConnection();
}
}
public static String getContentOfUrlByPostMethod( String url, NameValuePair[] nameValuePair, int connectionTimeout ) throws HttpException, IOException {
connectionTimeout = IntegerUtil.defaultIfZero( connectionTimeout, DEFAULT_CONNECTION_TIMEOUT );
// 鏋勯�HttpClient鐨勫疄渚�
HttpClient httpClient = new HttpClient();
// 鍒涘缓GET鏂规硶鐨勫疄渚�
PostMethod postMethod = new PostMethod( url );
postMethod.setRequestBody( nameValuePair );
// 浣跨敤绯荤粺鎻愪緵鐨勯粯璁ょ殑鎭㈠绛栫暐
postMethod.getParams().setParameter( HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler() );
HttpConnectionManagerParams managerParams = httpClient.getHttpConnectionManager().getParams();
// 璁剧疆杩炴帴瓒呮椂鏃堕棿(鍗曚綅姣)
managerParams.setConnectionTimeout( connectionTimeout );
// 璁剧疆璇绘暟鎹秴鏃舵椂闂�鍗曚綅姣)
managerParams.setSoTimeout( 60000 );
try {
// 鎵цgetMethod
int statusCode = httpClient.executeMethod( postMethod );
if ( statusCode != HttpStatus.SC_OK ) {
System.err.println( "Method failed: " + postMethod.getStatusLine() );
}
return IOUtil.convertInputStream2String( postMethod.getResponseBodyAsStream(), postMethod.getResponseCharSet() );
} finally {
// 閲婃斁杩炴帴
postMethod.releaseConnection();
}
}
public static Map< String, String > getContentOfUrl( Map< String, String > urls, int connectionTimeout ) throws HttpException, IOException {
Map< String, String > bodyContents = new HashMap< String, String >();
connectionTimeout = IntegerUtil.defaultIfZero( connectionTimeout, DEFAULT_CONNECTION_TIMEOUT );
// 鏋勯�HttpClient鐨勫疄渚�
HttpClient httpClient = new HttpClient();
// 鍒涘缓GET鏂规硶鐨勫疄渚�
GetMethod getMethod = new GetMethod();
// 浣跨敤绯荤粺鎻愪緵鐨勯粯璁ょ殑鎭㈠绛栫暐
getMethod.getParams().setParameter( HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler() );
HttpConnectionManagerParams managerParams = httpClient.getHttpConnectionManager().getParams();
// 璁剧疆杩炴帴瓒呮椂鏃堕棿(鍗曚綅姣)
managerParams.setConnectionTimeout( connectionTimeout );
// 璁剧疆璇绘暟鎹秴鏃舵椂闂�鍗曚綅姣)
managerParams.setSoTimeout( 60000 );
try {
for ( String key : urls.keySet() ) {
if ( StringUtil.isBlank( key ) )
continue;
String url = urls.get( key );
if ( StringUtil.isBlank( url ) )
continue;
getMethod.setURI( new URI( StringUtil.trimToEmpty( url ), true, "UTF-8" ) );
try {
// 鎵цgetMethod
int statusCode = httpClient.executeMethod( getMethod );
if ( statusCode != HttpStatus.SC_OK ) {
System.err.println( "Method failed: " + getMethod.getStatusLine() );
}
String content = IOUtil.convertInputStream2String( getMethod.getResponseBodyAsStream(), getMethod.getResponseCharSet() );
bodyContents.put( key, content );
System.out.println( content );
} catch ( Throwable e ) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return bodyContents;
} finally {
// 閲婃斁杩炴帴
getMethod.releaseConnection();
}
}
public static String getContentOfUrl( String url ) throws HttpException, IOException {
return NetUtil.getContentOfUrl( url, DEFAULT_CONNECTION_TIMEOUT );
}
public static Map< String, String > getContentOfUrl( Map< String, String > urls ) throws HttpException, IOException {
return NetUtil.getContentOfUrl( urls, DEFAULT_CONNECTION_TIMEOUT );
}
/**
* 192.168.37.111:51472 -> 192.168.37.111
* @param server 192.168.37.111:51472
* @return
*/
public static String getIpFromServer( String server ) {
if ( StringUtil.isBlank( server ) ) {
return EmptyObjectConstant.EMPTY_STRING;
}
try {
return StringUtil.trimToEmpty( StringUtil.splitWithLeastLength( server, SymbolConstant.COLON, 1 )[0] );
} catch ( Exception e ) {
return EmptyObjectConstant.EMPTY_STRING;
}
}
/**
* 192.168.37.111:51472 -> 192.168.37.111
* @param server 192.168.37.111:51472
* @return
*/
public static List< String > getIpFromServer( List< String > serverList ) {
List< String > ipList = new ArrayList< String >();
if ( CollectionUtil.isBlank( serverList ) ) {
return ipList;
}
for ( String server : serverList ) {
String ip = NetUtil.getIpFromServer( StringUtil.trimToEmpty( server ) );
if ( StringUtil.isBlank( ip ) )
continue;
ipList.add( ip );
}
return ipList;
}
}
|
[
"[email protected]"
] | |
dc65f32c72b4e174b6c0b2f64750a40319314361
|
6c16dec0fac54ed39a954c57dff870b0996ae6d6
|
/src/main/java/com/ynov/biblio/web/rest/vm/LoginVM.java
|
88264f62b6f8da2a00460f64cd28d8b15b44b51f
|
[
"MIT"
] |
permissive
|
hugoj78/projetBibliotheque
|
23d0ba0892fdac84a98e67cbd1b6149678ba2a84
|
fa1d989fffba9c74d3ae4f8f2d74fe0a9476ec0a
|
refs/heads/main
| 2023-02-03T05:53:11.962924 | 2020-12-12T18:06:10 | 2020-12-12T18:06:10 | 314,202,212 | 0 | 0 |
MIT
| 2020-12-12T18:06:47 | 2020-11-19T09:44:35 |
TypeScript
|
UTF-8
|
Java
| false | false | 1,075 |
java
|
package com.ynov.biblio.web.rest.vm;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
/**
* View Model object for storing a user's credentials.
*/
public class LoginVM {
@NotNull
@Size(min = 1, max = 50)
private String username;
@NotNull
@Size(min = 4, max = 100)
private String password;
private Boolean rememberMe;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Boolean isRememberMe() {
return rememberMe;
}
public void setRememberMe(Boolean rememberMe) {
this.rememberMe = rememberMe;
}
// prettier-ignore
@Override
public String toString() {
return "LoginVM{" +
"username='" + username + '\'' +
", rememberMe=" + rememberMe +
'}';
}
}
|
[
"[email protected]"
] | |
93b387c003ecadddc2ebd532739400b94ef21a19
|
eb185da84df66187fc17c40958846c6f132bca0c
|
/app/src/main/java/com/fanqi/succulent/util/NetworkUtil.java
|
63be35329a23ffe2eea44074f0a0c6d7018719f4
|
[] |
no_license
|
fanqi987/succulent
|
afae44ae60cf807bab6f81a2eb942f5463b6e0dd
|
e9305a686f20b91b2d533ec3cd47c98224ef9ae7
|
refs/heads/master
| 2020-12-21T06:46:33.534594 | 2020-02-07T10:29:15 | 2020-02-07T10:29:15 | 236,343,040 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 2,564 |
java
|
package com.fanqi.succulent.util;
import com.fanqi.succulent.activity.adapter.SucculentListAdapter;
import com.fanqi.succulent.network.FirstEnterRequester;
import com.fanqi.succulent.network.MediaInfoRequester;
import com.fanqi.succulent.network.SucculentPostRequester;
import com.fanqi.succulent.network.page.PagesRequester;
import com.fanqi.succulent.network.page.PagesBaseDataResolver;
import com.fanqi.succulent.presenter.listener.InitializeByPullListener;
import com.fanqi.succulent.presenter.listener.InitializeDataListener;
import com.fanqi.succulent.presenter.listener.InitializePostDataListener;
import com.fanqi.succulent.thread.MyDataThreadPool;
import com.fanqi.succulent.viewmodel.listener.ViewModelCallback;
import java.io.Serializable;
public class NetworkUtil {
private InitializeDataListener mDataListener;
private InitializeByPullListener mByPullListener;
private InitializePostDataListener mPostDataListener;
private ViewModelCallback mViewModelCallback;
public void initFirstEnterData() {
FirstEnterRequester requester = new FirstEnterRequester();
requester.doFirstInfoRequest(mDataListener);
}
public void pullDataFromPage(Object[] values) {
PagesRequester requester = new PagesRequester();
requester.doPullDataFromPage(mByPullListener, values);
}
public void postFullDataToServer(PagesBaseDataResolver pagesBaseDataResolver) {
SucculentPostRequester requester = new SucculentPostRequester();
requester.doPostDataToServer(mPostDataListener, pagesBaseDataResolver);
}
public void requestGetMediaInfo(String pageName) {
MediaInfoRequester requester = new MediaInfoRequester();
requester.doGetMediaInfo(mViewModelCallback, pageName);
}
public void requestGetSingleImage(String pageName, Serializable holder,int position) {
MediaInfoRequester requester = new MediaInfoRequester();
requester.doGetSingleImageUrl(mViewModelCallback, pageName, holder,position);
}
public void setInitializePostDataListener(InitializePostDataListener postDataListener) {
mPostDataListener = postDataListener;
}
public void setInitializeByPullListener(InitializeByPullListener pullListener) {
mByPullListener = pullListener;
}
public void setInitializeDataListener(InitializeDataListener dataListener) {
mDataListener = dataListener;
}
public void setViewModelCallback(ViewModelCallback viewModelCallback) {
mViewModelCallback = viewModelCallback;
}
}
|
[
"[email protected]"
] | |
f37ac6c7534355a68bf3d9c6f7e2086db935906c
|
d506fb550333ee9daa7a900d19d196a52e979e64
|
/adapters-output/src/main/java/de/valentin/master/core/events/projectcreated/ProjectCreatedProjection.java
|
f54b224e4f3dc12c364f2459aa12cc6af9ab95df
|
[] |
no_license
|
vallout/master_thesis_backend
|
dfc3910eaea509bcc9c6ccba094321a6a34f8512
|
461d6ef6120a12a78459af470e2565239780b765
|
refs/heads/main
| 2023-03-09T15:20:45.541210 | 2021-02-25T10:17:37 | 2021-02-25T10:17:37 | 341,950,939 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 604 |
java
|
package de.valentin.master.core.events.projectcreated;
import org.bson.types.ObjectId;
public class ProjectCreatedProjection {
private ObjectId userId;
private ObjectId projectId;
private long timestamp;
public ObjectId getUserId() {
return userId;
}
public void setUserId(ObjectId userId) {
this.userId = userId;
}
public ObjectId getProjectId() {
return projectId;
}
public void setProjectId(ObjectId projectId) {
this.projectId = projectId;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
}
|
[
"[email protected]"
] | |
c536b51ee471f858c57ee33ddea68a59f2f705aa
|
505d026815959f7d98122c5f9c4ece240929e70f
|
/netty/src/main/java/com/hdbsoft/spring/netty/telnet/TelnetServerHandler.java
|
ee9a4afbc331af23092a728b99eaa9ac9b983ed5
|
[] |
no_license
|
jhopil/spring-boot
|
d6923aeac8a42f5fe08cf2d4ec2f089e67ad60d0
|
337aa5dab8bed1b13a0693c39a55d1d157725f2b
|
refs/heads/master
| 2021-01-02T15:22:19.539899 | 2020-02-27T02:07:41 | 2020-02-27T02:07:41 | 239,679,860 | 0 | 0 | null | null | null | null |
UTF-8
|
Java
| false | false | 1,407 |
java
|
package com.hdbsoft.spring.netty.telnet;
import io.netty.channel.*;
import java.net.InetAddress;
import java.util.Date;
@ChannelHandler.Sharable
public class TelnetServerHandler extends SimpleChannelInboundHandler<String> {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.write("welcome to " + InetAddress.getLocalHost().getHostName() + "!\r\n");
ctx.write("it is " + new Date() + " now.!\r\n");
ctx.flush();
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, String request) throws Exception {
String response;
boolean close = false;
if(request.isEmpty()) {
response = "please type something.\r\n";
} else if("bye".equals(request.toLowerCase())) {
response = "have a good day!\r\n";
close = true;
} else {
response = "did you say '" + request + "' ? \r\n";
}
ChannelFuture future = ctx.write(response);
if(close) {
future.addListener(ChannelFutureListener.CLOSE);
}
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
|
[
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.