blob_id
stringlengths 40
40
| language
stringclasses 1
value | repo_name
stringlengths 5
132
| path
stringlengths 2
382
| src_encoding
stringclasses 34
values | length_bytes
int64 9
3.8M
| score
float64 1.5
4.94
| int_score
int64 2
5
| detected_licenses
listlengths 0
142
| license_type
stringclasses 2
values | text
stringlengths 9
3.8M
| download_success
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|
bee549ed5b727d96d5b703e7acd556a2db60dae5
|
Java
|
kotawarakshay/Final-project
|
/TestingModules/src/com/util/DBConnection.java
|
UTF-8
| 1,199
| 2.6875
| 3
|
[] |
no_license
|
package com.util;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
public class DBConnection {
private static Connection connection;
private static DBConnection instance = null;
public static Connection getConnection() throws SQLException, IOException {
Properties properties=new Properties();
FileInputStream fis=new FileInputStream("resources/jdbc.properties");
properties.load(fis);
String url=properties.getProperty("url");
String driver=properties.getProperty("driver");
String user=properties.getProperty("username");
String password=properties.getProperty("password");
try {
Class.forName(driver);
try {
connection=DriverManager.getConnection(url,user,password);
//System.out.println("connected");
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return connection;
}
}
| true
|
3cc81328de0f1daf2c7dea50b409beeb5928daf8
|
Java
|
miguelperezcolom/backend-technical-test-v2
|
/src/main/java/com/tui/proof/miguel/application/ws/order/dtos/AddressDTO.java
|
UTF-8
| 506
| 1.976563
| 2
|
[
"Apache-2.0"
] |
permissive
|
package com.tui.proof.miguel.application.ws.order.dtos;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Pattern;
/**
* The address DTO
*
* @author Miguel Pérez Colom
* @date 25/10/2021
*/
@Data@AllArgsConstructor
@NoArgsConstructor
public class AddressDTO {
@NotBlank
private String street;
@NotBlank
private String city;
}
| true
|
56fddadca8f8f778963c3cd3f58be231a4a97145
|
Java
|
bduncan4410/CS-499
|
/Brian DuncanProjectTwo/src/main/java/Controllers/ContactController.java
|
UTF-8
| 3,064
| 2.96875
| 3
|
[] |
no_license
|
package Controllers;
import Database.*;
import Models.ContactModel;
import Models.TaskModel;
import java.sql.ResultSet;
import java.sql.SQLException;
import sun.jvm.hotspot.utilities.soql.SOQLException;
public class ContactController
{
private ConnectionController connCont;
public ContactController() throws SOQLException
{
try
{
this.connCont = new ConnectionController() ;
}
catch (SQLException e)
{
}
}
public ContactModel viewTask(int id)
{
String query = "Select from Tasks where ID = \"" + id+ "\"";
try
{
return toModel(connCont.executeReadQuery(query));
}
catch (Exception e)
{
return null;
}
}
/*Adds an Task to the list of Tasks
* also ensures that the Task id is unique.
*/
public boolean addContact (int ID, String name, String desc)
{
TaskModel newTask;
try
{
newTask = new TaskModel(ID, name, desc);
//if the Task id is not unique an exception will be thown.
connCont.executeQuery(newTask.createInsertString());
return true;
}
catch(Exception e)
{
return false;
}
}
public boolean removeContact (ContactModel newContact)
{
try
{
connCont.executeQuery(newContact.createDeleteString());
return true;
}
catch (SQLException e)
{
return false;
}
}
private ContactModel toModel(ResultSet rawSQL) throws SQLException, Exception
{
int ID = (int)rawSQL.getInt("ID");
String firstName = rawSQL.getString("First Name");
String lastName = rawSQL.getString("Last Name");
String phoneNum= rawSQL.getString("Phone Number");
String address = rawSQL.getString("Address");
ContactModel newContact = new ContactModel(ID, firstName, lastName, phoneNum, address);
return newContact;
}
public boolean updateFirstName(String ID, String newFirstName) throws Exception
{
try
{
connCont.executeQuery("Update Customers Set First_Name = '" + newFirstName + "' WHERE CustomerID = " + ID +";" );
return true;
}
catch (SQLException e)
{
return false;
}
}
public boolean updateLastName(String ID, String newLastName) throws Exception
{
try
{
connCont.executeQuery("Update Customers Set First_Name = '" + newLastName + "' WHERE CustomerID = " + ID +";" );
return true;
}
catch (SQLException e)
{
return false;
}
}
}
| true
|
0bd1fee970d82a41f9ffbd5055f5c97853e0ffff
|
Java
|
bmw546/tamtaam
|
/Android/Tamtam/app/src/main/java/tamtam/tamtam/rabais.java
|
UTF-8
| 1,697
| 2.4375
| 2
|
[] |
no_license
|
package tamtam.tamtam;
import java.util.Date;
public class rabais {
private String code;
private float montant;
private String description;
private String dateDebut;
private String dateFin;
private char type;
public rabais() {
}
public rabais(String code_rabais, float montant, String description, String dateDebut, String dateFin, char type) {
this.code = code_rabais;
this.montant = montant;
this.description = description;
this.dateDebut = dateDebut;
this.dateFin = dateFin;
this.type = type;
}
public String getCode() {
return code;
}
public void setCode(String code_rabais) {
this.code = code_rabais;
}
public float getMontant() {
return montant;
}
public void setMontant(float montant) {
this.montant = montant;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getDateDebut() {
return dateDebut;
}
public void setDateDebut(String dateDebut) {
this.dateDebut = dateDebut;
}
public String getDateFin() {
return dateFin;
}
public void setDateFin(String dateFin) {
this.dateFin = dateFin;
}
public char getType() {
return type;
}
public int getNoType(){
int type = 0;
if (this.type == '$'){
type = 1;
}else if(this.type == '%'){
type = 2;
}
return type;
}
public void setType(char id_type) {
this.type = id_type;
}
}
| true
|
093758b0233835f1d70438bd7b323243baf6364c
|
Java
|
shubhamg2-optimus/Java_Reusable_Framework
|
/src/test/java/com/amazon/mob/tests/AmazonMobLoginTest.java
|
UTF-8
| 1,475
| 2.4375
| 2
|
[] |
no_license
|
package com.amazon.mob.tests;
import org.apache.log4j.Logger;
import org.testng.Assert;
import org.testng.annotations.Test;
import com.amazon.mob.pages.HomeMobPage;
import com.amazon.mob.pages.LoginMobPage;
import com.amazon.mob.pages.MobCategoryPage;
import io.qameta.allure.Description;
public class AmazonMobLoginTest extends BaseMobTest {
public static Logger LOGGER = Logger.getLogger(AmazonMobLoginTest.class);
public LoginMobPage loginMobPage;
public HomeMobPage homeMobPage;
public MobCategoryPage categoryPage;
/*
* Verify user is able to open the Sign-in/Login page
*/
@Description("<b>Test Step</b>:Verify user is able to open the Sign-in/Login page<br>"
+ "<b>Expected Result</b>:<br>"
+ "<ul><li>User should be navigated to login page"
+ "</ul>")
@Test(description = "Verify user is able to open the Sign-in/Login page")
public void verifyLoginPage() {
try {
LOGGER.info("Verify user is able to open the Sign-in/Login page");
loginMobPage = new LoginMobPage(driver);
loginMobPage.clickOnSignInButton();
Assert.assertTrue(loginMobPage.verifyLoginPageIsVisible());
} catch (Exception exception) {
LOGGER.error("Error while opening the Sign-in/Login page");
// Terminating test case execution because of an unexpected
// addressPageplication/environment/network error
Assert.fail(exception.getMessage());
}
}
}
| true
|
a9877d2e5c3283b014562ba33fbf16865f11633e
|
Java
|
SengarWu/Graduates
|
/app/src/main/java/com/xpple/graduates/ui/SplashActivity.java
|
UTF-8
| 3,407
| 1.921875
| 2
|
[] |
no_license
|
package com.xpple.graduates.ui;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import com.bmob.pay.tool.BmobPay;
import com.ktplay.open.KTPlay;
import com.xpple.graduates.R;
import com.xpple.graduates.config.Config;
import com.xpple.graduates.util.SpSettingsUtil;
import com.xpple.graduates.view.BaseActivity;
import net.slidingmenu.tools.AdManager;
import net.slidingmenu.tools.st.SpotManager;
public class SplashActivity extends BaseActivity {
private static final int GO_GUIDE = 100;
private static final int GO_MAIN = 200;
private Boolean user_first, isUserSuggest;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_splash);
SpSettingsUtil mSharedSettingsUtil = mApplication.getSpSettingsUtil();
user_first = mSharedSettingsUtil.isAllowFirst();
isUserSuggest = mSharedSettingsUtil.isUserSuggest();
// 必须先初始化
BmobPay.init(this, Config.BMOB_KEY);
// 初始化 KTPlay SDK
KTPlay.startWithAppKey(this, Config.KTPLAY_KEY, Config.KTPLAY_SECRET);
// 初始化 有米广告 SDK
if (!isUserSuggest) {
AdManager.getInstance(this).init(Config.YOUMI_KEY, Config.YOUMI_SECRET, false);
// 开启用户数据统计服务,默认不开启，传入 false 值也不开启，只有传入 true 才会调用
AdManager.getInstance(this).setUserDataCollect(true);
}
}
@Override
protected void onResume() {
super.onResume();
if (user_first) {
mHandler.sendEmptyMessageDelayed(GO_GUIDE, 1500);
} else {
mHandler.sendEmptyMessageDelayed(GO_MAIN, 1500);
}
}
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case GO_GUIDE:
startAnimActivity(GuideActivity.class);
finish();
break;
case GO_MAIN:
if (!isUserSuggest) {
goAdsAndMain();
} else {
startAnimActivity(MainActivity.class);
finish();
}
break;
}
super.handleMessage(msg);
}
};
private void goAdsAndMain() {
if (isNetConnected()) {
SpotManager.getInstance(this).showSplashSpotAds(this, MainActivity.class);
} else {
startAnimActivity(MainActivity.class);
finish();
}
}
// 请务必加上词句，否则进入网页广告后无法进去原sdk
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (resultCode == 10045) {
Intent intent = new Intent(this, MainActivity.class);
startActivity(intent);
finish();
}
}
@Override
protected void onStop() {
super.onStop();
SpotManager.getInstance(this).onStop();
}
@Override
protected void onDestroy() {
super.onDestroy();
SpotManager.getInstance(this).onDestroy();
}
}
| true
|
5d243d8c4e896420026e7a895a80bf7ef2fdde81
|
Java
|
antlko/kafedra-informatic-coursework-api
|
/src/main/java/com/example/entity/Teacher.java
|
UTF-8
| 658
| 2.078125
| 2
|
[
"MIT"
] |
permissive
|
package com.example.entity;
import com.fasterxml.jackson.annotation.JsonSetter;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
@Entity
@Table(name = "teachers")
@Data
@NoArgsConstructor
public class Teacher {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long Id;
@Column(name = "photo")
private String photo;
@Column(name = "name")
private String name;
@Column(name = "description")
private String description;
@Column(name = "email")
private String email;
@Column(name = "info_json")
@JsonSetter(value = "info_json")
private String infoJSON;
}
| true
|
c57faf36973da18abc8a38f60b3f60c0e49fe9c7
|
Java
|
adrianrodmed/Moda
|
/Moda/src/Main/Main.java
|
ISO-8859-10
| 2,376
| 3.15625
| 3
|
[] |
no_license
|
package Main;
import java.util.ArrayList;
import PolimorfismoInterface.Disenador;
import PolimorfismoInterface.Modelo;
import PolimorfismoInterface.Estilista;
import PolimorfismoInterface.SeleccionModa;
public class Main {
// ArrayList de objetos SeleccionFutbol. Idenpendientemente de la clase hija a la que pertenezca el objeto
public static ArrayList<SeleccionModa> integrantes = new ArrayList<SeleccionModa>();
public static void main(String[] args) {
SeleccionModa armani = new Disenador(1, "Giorgio", "Armani", 60, 28489);
SeleccionModa eva = new Modelo(2, "Eva", "Longoria", 29, 6, "Hombre");
SeleccionModa raulMartinez = new Estilista(3, "Raul", "Martinez", 41, "Licenciado en Estilismo", 18);
integrantes.add(armani);
integrantes.add(eva);
integrantes.add(raulMartinez);
// CONCENTRACION
System.out.println("Todos los integrantes comienzan una desfile. (Todos ejecutan el mismo metodo)");
for (SeleccionModa integrante : integrantes) {
System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> ");
integrante.fecha();
}
// VIAJE
System.out.println("\nTodos los integrantes viajan para desfilar. (Todos ejecutan el mismo metodo)");
for (SeleccionModa integrante : integrantes) {
System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> ");
integrante.viajar();
}
// ENTRENAMIENTO
System.out.println("\nEntrenamiento: Todos los integrantes tienen su funcion en un desfile (Especializacion)");
for (SeleccionModa integrante : integrantes) {
System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> ");
integrante.desfile();
}
// DISEAR VESTIDO
System.out.println("\nPlanificar Desfile: Solo el diseador tiene el metodo para planificar un desfile:");
System.out.print(armani.getNombre() + " " + armani.getApellidos() + " -> ");
((Disenador) armani).disenarVestido();
// ENTREVISTA
System.out.println("\nEntrevista: Solo el modelo tiene el metodo para dar una entrevista:");
System.out.print(eva.getNombre() + " " + eva.getApellidos() + " -> ");
((Modelo) eva).entrevista();
// MASAJE
System.out.println("\nMasaje: Solo el estilista tiene el metodo para maquillar:");
System.out.print(raulMartinez.getNombre() + " " + raulMartinez.getApellidos() + " -> ");
((Estilista) raulMartinez).maquillar();
}
}
| true
|
1800fcb93d9834c05bb575311ff04f65d07c54f5
|
Java
|
pochona/M2_EAI_Events
|
/ProjetEvents/ProjetEvents-ejb/src/java/singleton/SalleSingleton.java
|
UTF-8
| 3,076
| 2.328125
| 2
|
[] |
no_license
|
/*
* 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 singleton;
import java.util.HashMap;
import javax.annotation.Resource;
import javax.ejb.EJB;
import javax.ejb.Singleton;
import javax.ejb.LocalBean;
import javax.inject.Inject;
import javax.jms.JMSContext;
import javax.jms.MapMessage;
import javax.jms.Queue;
import messages.Salle;
/**
*
* @author Amaury_PC
*/
@Singleton
@LocalBean
public class SalleSingleton {
@Resource(lookup = "Event_Salle")
private Queue queueSalle;
@Inject
private JMSContext contextSalle;
@EJB
ProjetSingleton projet;
private final HashMap<Integer, Salle> salles;
public SalleSingleton() {
salles = new HashMap<>();
Salle s1 = new Salle(1, 150, "simple", false);
Salle s2 = new Salle(2, 100, "simple", false);
Salle s3 = new Salle(3, 300, "simple", true);
Salle s4 = new Salle(4, 150, "importante", true);
Salle s5 = new Salle(5, 300, "importante", true);
Salle s6 = new Salle(6, 150, "simple", true);
salles.put(s1.getNumeroSalle(), s1);
salles.put(s2.getNumeroSalle(), s2);
salles.put(s3.getNumeroSalle(), s3);
salles.put(s4.getNumeroSalle(), s4);
salles.put(s5.getNumeroSalle(), s5);
salles.put(s6.getNumeroSalle(), s6);
}
public Salle réserverSalle(int capacitéMax, String typePrestation) {
int numeroSalle = 0;
switch (numeroSalle) {
case 2 :
if (capacitéMax <= 100 && (typePrestation == "cocktail" || typePrestation == "lunch"));
break;
case 1 :
if (capacitéMax >100 && capacitéMax <= 150 && (typePrestation == "cocktail" || typePrestation == "lunch"));
break;
case 3 :
if (capacitéMax >150 && capacitéMax <= 300 && (typePrestation == "cocktail" || typePrestation == "lunch"));
break;
case 4 :
if (capacitéMax <= 150 && typePrestation == "repasAssis");
break;
case 5 :
if (capacitéMax >150 && capacitéMax <= 300 && typePrestation == "repasAssis");
break;
case 6 :
if (capacitéMax >100 && capacitéMax <= 150 && (typePrestation == "cocktail" || typePrestation == "lunch"));
break;
}
Salle s = salles.get(numeroSalle);
s.setDisponible(false);
MapMessage message = contextSalle.createMapMessage();
contextSalle.createProducer().send(queueSalle, s);
return s;
}
public String annulerSalle(int numSalle){
Salle s = salles.get(numSalle);
s.setDisponible(true);
return "Salle annulée avec succès";
}
}
| true
|
b63ab5b223fa3c05f5b85f1eb6e4df156d814f68
|
Java
|
shift/nerlo
|
/priv/java/src/main/java/org/ister/ej/EjList.java
|
UTF-8
| 228
| 1.921875
| 2
|
[
"BSD-3-Clause"
] |
permissive
|
package org.ister.ej;
import java.util.List;
/**
* This interface represents a functional list type.
*
* @author ingo
*
* @param <E>
*/
public interface EjList extends List<Object> {
public List<Object> toList();
}
| true
|
5136f25f374e70edb9ce6731a1280063cc9fe578
|
Java
|
ewalu/polisa-jdbc2
|
/EJBSzkol/src/pl/edu/atena/rest/ws/klient/SymbolRyzyka.java
|
UTF-8
| 1,198
| 2.359375
| 2
|
[] |
no_license
|
package pl.edu.atena.rest.ws.klient;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;
/**
* <p>Java class for symbolRyzyka.
*
* <p>The following schema fragment specifies the expected content contained within this class.
* <p>
* <pre>
* <simpleType name="symbolRyzyka">
* <restriction base="{http://www.w3.org/2001/XMLSchema}string">
* <enumeration value="J07"/>
* <enumeration value="C02"/>
* <enumeration value="H04"/>
* </restriction>
* </simpleType>
* </pre>
*
*/
@XmlType(name = "symbolRyzyka")
@XmlEnum
public enum SymbolRyzyka {
@XmlEnumValue("J07")
J_07("J07"),
@XmlEnumValue("C02")
C_02("C02"),
@XmlEnumValue("H04")
H_04("H04");
private final String value;
SymbolRyzyka(String v) {
value = v;
}
public String value() {
return value;
}
public static SymbolRyzyka fromValue(String v) {
for (SymbolRyzyka c: SymbolRyzyka.values()) {
if (c.value.equals(v)) {
return c;
}
}
throw new IllegalArgumentException(v);
}
}
| true
|
b32344661e118f7b5716edee49292c9420451dba
|
Java
|
aheadlcx/analyzeApk
|
/zuiyou/sources/rx/e/b.java
|
UTF-8
| 590
| 1.664063
| 2
|
[] |
no_license
|
package rx.e;
import rx.exceptions.a;
public abstract class b {
@Deprecated
public void a(Throwable th) {
}
public final String a(Object obj) {
try {
return b(obj);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return obj.getClass().getName() + ".errorRendering";
} catch (Throwable th) {
a.b(th);
return obj.getClass().getName() + ".errorRendering";
}
}
protected String b(Object obj) throws InterruptedException {
return null;
}
}
| true
|
83da9bdf72c1711f9faa97a5f0a56025a9b6b54f
|
Java
|
fbiville/liquigraph
|
/liquigraph-core/src/main/java/org/liquigraph/core/io/xml/DomSourceValidatorFactory.java
|
UTF-8
| 1,124
| 1.648438
| 2
|
[
"Apache-2.0"
] |
permissive
|
/*
* Copyright 2014-2016 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.liquigraph.core.io.xml;
import javax.xml.transform.dom.DOMSource;
public class DomSourceValidatorFactory {
private final SchemaDetector schemaDetector;
public DomSourceValidatorFactory() {
schemaDetector = new SchemaDetector();
}
public DomSourceValidator createValidator(DOMSource source) {
if (schemaDetector.hasExplicitSchema(source)) {
return new ExplicitSchemaValidator();
}
return new ImplicitSchemaValidator();
}
}
| true
|
4a33301b936c2013348409ffda78ce0ce2b044fc
|
Java
|
AlexanderLegon/ENG87-FinalProject
|
/src/main/java/com/sparta/eng87/finalproject/controllers/DisciplineController.java
|
UTF-8
| 2,127
| 2.3125
| 2
|
[] |
no_license
|
package com.sparta.eng87.finalproject.controllers;
import com.sparta.eng87.finalproject.entities.DisciplineEntity;
import com.sparta.eng87.finalproject.services.DisciplineService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class DisciplineController {
private DisciplineService disciplineService;
@Autowired
public DisciplineController(DisciplineService disciplineService) {
this.disciplineService = disciplineService;
}
@GetMapping("/addDiscipline")
public String getAddDisciplinePage() {
return "addDiscipline";
}
@PostMapping("/addDiscipline")
public String addDiscipline(@RequestParam(name = "discipline-name") String disciplineName,
@RequestParam(name = "discipline-duration") Integer disciplineDuration) {
disciplineService.addDiscipline(new DisciplineEntity(disciplineName, disciplineDuration));
return "redirect:/extraCourseInfoPage";
}
@GetMapping("/editDiscipline/{id}")
public String updateDiscipline(@PathVariable("id") Integer id, Model model) {
model.addAttribute("discipline", disciplineService.findDisciplineById(id));
return "editDiscipline";
}
@PostMapping("/updateDiscipline/{id}")
public String updateDiscipline(DisciplineEntity disciplineEntity, @PathVariable("id") Integer id) {
disciplineEntity.setDiscipline_id(id);
disciplineService.addDiscipline(disciplineEntity);
return "redirect:/extraCourseInfoPage";
}
@GetMapping("/removeDiscipline/{id}")
public String removeDiscipline(DisciplineEntity disciplineEntity, @PathVariable("id") Integer id) {
disciplineService.deleteDiscipline(id);
return "redirect:/extraCourseInfoPage";
}
}
| true
|
ee24e147f44f196765a89fe1e578c80ffccd799f
|
Java
|
tornado1512/Advance-java
|
/18_ServletConfig/WEB-INF/src/AbcServlet.java
|
UTF-8
| 550
| 1.679688
| 2
|
[] |
no_license
|
import javax.servlet.http.HttpServlet;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
public class AbcServlet extends HttpServlet
{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws IOException,ServletException{
ServletConfig sc=getServletConfig();//here grtServletConfig will runs in the same context is of conaitner hence object f actionServlet
System.out.println(sc);
}
}
| true
|
eb1454b50c5c6a86fb665be464d12960f1181312
|
Java
|
doc97/Gwent
|
/src/main/java/fi/riissanen/gwent/engine/net/Server.java
|
UTF-8
| 3,505
| 3.3125
| 3
|
[] |
no_license
|
package fi.riissanen.gwent.engine.net;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
/**
* Functions as the server in a TCP/IP() network.
* @author Daniel
*/
public class Server implements PacketListener {
private static final int MAX_CLIENTS = 100;
private final Map<Integer, ClientHandler> clients = new HashMap<>();
private PacketListener listener;
private ServerSocket socket;
/**
* Starts to listen for incoming connection on a port.
* @param port The port on which to listen
* @throws IOException If an error occurs while waiting for a connection
*/
public void listen(int port) throws IOException {
socket = new ServerSocket(port);
while (true) {
Socket client = socket.accept();
int id = getFreeID();
if (id == -1) {
client.close();
continue;
}
System.out.println("Client connected with id: " + id);
ClientHandler handler = new ClientHandler(this, client, id);
handler.start();
handler.sendPacket(new ConnectionPacket(id, handler.getID()));
clients.put(id, handler);
}
}
/**
* Closes the server socket.
* @throws IOException If an error occurs while closing the socket
*/
public void close() throws IOException {
socket.close();
}
/**
* Frees the client handler for a certain id.
* @param id The id of the client (handler)
*/
public void freeClient(int id) {
System.out.println("Client with id " + id + " disconnected!");
clients.remove(id);
}
/**
* Sets the listener to which packets are forwarded.
* @param listener Listener to forward to
*/
public void setPacketListener(PacketListener listener) {
if (!listener.equals(this)) {
this.listener = listener;
}
}
private int getFreeID() {
int id = getID() + 1;
do {
if (!clients.containsKey(id)) {
return id;
} else {
id++;
}
} while (id < MAX_CLIENTS);
return -1;
}
/**
* Gets the server's id, clients start from 1.
* @return 0
*/
public int getID() {
return 0;
}
/**
* Sends a packet to the client with a certain id.
* @param targetClient The ID of the client
* @param packet The packet to send
* @return The success of adding the packet to the queue
*/
public boolean sendPacket(int targetClient, Packet packet) {
if (!clients.containsKey(targetClient)) {
throw new IllegalArgumentException("Can't send packet to client with ID: " + targetClient);
}
if (packet.getSenderID() != getID()) {
throw new IllegalArgumentException("Trying to send packet from server with different sender ID than the server's");
}
return clients.get(targetClient).sendPacket(packet);
}
/**
* Gets a {@code ClientHandler} by id.
* @param id The client id
* @return The client handler
*/
public ClientHandler getClient(int id) {
return clients.get(id);
}
@Override
public void receivedPacket(Packet packet) {
if (listener != null) {
listener.receivedPacket(packet);
}
}
}
| true
|
e132f09005e647b0751e4bc0d900405e868dddba
|
Java
|
ServiceInnovationLab/CentralDelegationService
|
/src/test/java/delegations/cds/services/RendezvousServiceTest.java
|
UTF-8
| 2,821
| 1.867188
| 2
|
[
"MIT"
] |
permissive
|
package delegations.cds.services;
import static org.assertj.core.api.Assertions.assertThat;
import javax.inject.Inject;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.arquillian.persistence.DataSource;
import org.jboss.arquillian.persistence.UsingDataSet;
import org.jboss.shrinkwrap.api.Filters;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.jboss.shrinkwrap.resolver.api.maven.Maven;
import org.jboss.shrinkwrap.resolver.api.maven.PomEquippedResolveStage;
import org.jboss.shrinkwrap.resolver.api.maven.ScopeType;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.querydsl.jpa.impl.JPAQuery;
import delegations.cds.models.Delegation;
import delegations.cds.models.Email;
import delegations.cds.models.QDelegation;
@DataSource(value = "jboss/datasources/TestDS")
@RunWith(Arquillian.class)
public class RendezvousServiceTest {
@Inject
private RendezvousService rendezvousService;
@Deployment
public static WebArchive deployment() {
WebArchive war = ShrinkWrap.create(WebArchive.class);
war.addPackages(true, Filters.exclude(".*Test.*"), "delegations.cds");
war.addAsWebInfResource("test-beans.xml", "beans.xml");
PomEquippedResolveStage resolver = Maven.resolver().loadPomFromFile("pom.xml");
war.addAsLibraries(resolver
.importDependencies(ScopeType.PROVIDED, ScopeType.COMPILE, ScopeType.RUNTIME, ScopeType.TEST)
.resolve()
.withTransitivity()
.asFile());
war.addAsResource("test-persistence.xml", "META-INF/persistence.xml");
war.addAsResource("test-project-defaults.yml", "project-defaults.yml");
return war;
}
@Test
@UsingDataSet("rendezvous-one.yml")
public void canGenerateEmail() {
String crn = "crn:dia:test::delegation/43046b2b-839a-4aba-a50e-c70212d88fc4";
Delegation delegation = query()
.from(QDelegation.delegation)
.select(QDelegation.delegation)
.where(QDelegation.delegation.crn.eq(crn)).fetchOne();
Email email = rendezvousService.generateEmail(delegation);
assertThat(email).isNotNull();
assertThat(email.content()).contains(
"<span>user1@example.com</span> has requested to share " +
"<span>crn:dia:test:123456789012:templates/passport-1</span> " +
"with <span >user2@example.com</span>"
);
}
protected JPAQuery<?> query() {
JPAQuery<?> query = new JPAQuery<>(em);
return query;
}
@PersistenceContext
protected EntityManager em;
}
| true
|
b18424f4125ec1434a8c3ccd35387ac05e70f66a
|
Java
|
andrewdotn/grubbyjar
|
/src/test/java/ca/neitsch/grubbyjar/TestUtil.java
|
UTF-8
| 1,401
| 2.5625
| 3
|
[
"BSD-2-Clause"
] |
permissive
|
package ca.neitsch.grubbyjar;
import org.apache.commons.io.IOUtils;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
public class TestUtil {
private TestUtil() {
throw new UnsupportedOperationException("static class");
}
/** Assumes text file */
public static String readResource(String path) {
InputStream stream = inputResource(path, 3);
try {
return IOUtils.toString(stream, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static InputStream inputResource(String path, int depth) {
String className = getCallingClassName(depth);
String packageName = className.substring(0,
className.lastIndexOf("."));
String lookupPath = "/"
+ packageName.replace(".", "/")
+ "/" + path;
InputStream ret = TestUtil.class.getResourceAsStream(lookupPath);
if (ret == null) {
throw new RuntimeException(lookupPath + " not found in classpath");
}
return ret;
}
static String getCallingClassName(int depth) {
StackTraceElement e[]
= new Exception().fillInStackTrace().getStackTrace();
return e[depth].getClassName();
}
}
| true
|
5e9a1f8977c3325b84fb49a7e71c58ec46d5b3e9
|
Java
|
skypep/Family-Child
|
/app/src/main/java/com/toro/helper/view/SafeguardRadiusItem.java
|
UTF-8
| 1,168
| 2.078125
| 2
|
[] |
no_license
|
package com.toro.helper.view;
import android.content.Context;
import android.util.AttributeSet;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import com.toro.helper.R;
import org.w3c.dom.Text;
/**
* Create By liujia
* on 2018/11/3.
**/
public class SafeguardRadiusItem extends RelativeLayout {
private TextView titleView;
private ImageView selectedView;
private int value;
public SafeguardRadiusItem(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
titleView = findViewById(R.id.title_text);
selectedView = findViewById(R.id.selected_icon);
}
public void init(int textRes,int value){
this.value = value;
titleView.setText(textRes);
selectedView.setVisibility(GONE);
}
public void setSelected(boolean flag) {
if(flag) {
selectedView.setVisibility(VISIBLE);
} else {
selectedView.setVisibility(GONE);
}
}
public int getValue() {
return value;
}
}
| true
|
8417745740a3c1bf9d107be05386b1c73790ccda
|
Java
|
SergySanJj/FileSystem
|
/FileSystem/src/main/java/com/filesys/FileSystem.java
|
UTF-8
| 15,245
| 2.65625
| 3
|
[
"MIT"
] |
permissive
|
package com.filesys;
import com.filesys.disk.Directory;
import java.io.File;
import java.io.PrintStream;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.util.BitSet;
public class FileSystem {
public static final int bitmapByteLength = 8;
public static final int fileDescriptorCount = 24;
private DiskIO dio;
private BitSet bitmap;
private FileDescriptor[] fileDescriptors;
private Directory directory;
private OpenFileTable oft;
private PrintStream printStream;
public FileSystem(DiskIO dio, PrintStream printStream) {
this.printStream = printStream;
this.dio = dio;
}
public void initFileSystem() {
bitmap = new BitSet(bitmapByteLength * 8);
bitmap.set(0, 8, true);
fileDescriptors = new FileDescriptor[fileDescriptorCount];
directory = new Directory();
oft = new OpenFileTable();
oft.getHandlers()[0] = new OpenFileTable.FileHandler();
oft.getHandlers()[0].fileDescr = 0;
}
public void initEmptyFileSystem() {
int fdsPerBlock = FileDescriptor.descriptorSize * fileDescriptorCount / DiskIO.getBlockSize();
fileDescriptors[0] = new FileDescriptor(0, new int[]{fdsPerBlock + 1, fdsPerBlock + 2, fdsPerBlock + 3});
}
public void loadFileSystem() {
ByteBuffer blockBuffer = ByteBuffer.allocate(DiskIO.getBlockSize());
dio.read_block(0, blockBuffer);
bitmap = BitSet.valueOf(blockBuffer);
fileDescriptors = new FileDescriptor[fileDescriptorCount];
FileDescriptor.deserializeFromDisk(dio, fileDescriptors);
try {
Directory.deserializeFromDisk(directory, dio);
} catch (Exception e) {
e.printStackTrace();
}
}
public void saveFileSystem(String diskName) {
for (int i = 1; i < oft.getHandlers().length; i++) {
if (oft.getHandlers()[i] != null)
closeFile(i);
}
dio.write_block(0, ByteBuffer.wrap(bitsetToByteArray(bitmap)));
FileDescriptor.serializeToDisk(fileDescriptors, dio);
Directory.serializeToDisk(directory, dio);
dio.saveAs(diskName);
}
public void closeFile(int fileHandlerIndex) {
if (fileHandlerIndex <= 0) {
errorDrop("Open files indexing starts from 1");
return;
} else if (checkOFTIndex(fileHandlerIndex) == ERR) {
errorDrop("Open file index does not exist");
return;
}
OpenFileTable.FileHandler fileHandler = oft.getHandlers()[fileHandlerIndex];
if (fileDescriptors[fileHandler.fileDescr].fileLen > 0 && fileHandler.bufferModified) {
FileDescriptor fileDescriptor = fileDescriptors[fileHandler.fileDescr];
int currentFileBlock = fileHandler.fileBlockInBuffer;
if (isEOF(fileHandler.fileDescr)) {
currentFileBlock--;
}
try {
int currentDiskBlock = fileDescriptor.blockNumbers[currentFileBlock];
dio.write_block(currentDiskBlock, oft.getHandlers()[fileHandlerIndex].currData);
} catch (Exception e) {// pass
}
}
oft.getHandlers()[fileHandlerIndex] = null;
printStream.println("File " + fileHandlerIndex + " closed");
}
public void createFile(String fileName) {
fileName = fillToFileNameLen(fileName);
if (fileName.length() > Directory.maxFileName) {
errorDrop("File name must be less than " + Directory.maxFileName + " long");
return;
} else if (directory.getFiles().size() == FileSystem.fileDescriptorCount - 1) {
errorDrop("No more files can be created");
return;
}
int descriptorIndex = getFreeDescriptorIndex();
if (descriptorIndex == -1) {
errorDrop("No more files can be created");
return;
}
if (fileExists(fileName)) {
errorDrop("File " + fileName + " already exists");
return;
}
try {
directory.addEntry(fileName, descriptorIndex);
} catch (Exception e) {
e.printStackTrace();
}
fileDescriptors[descriptorIndex] = new FileDescriptor();
printStream.println("File " + fileName + " created");
}
public boolean fileExists(String fileName) {
boolean fileExists = false;
for (Directory.DirFile dirFile : directory.getFiles()) {
if (dirFile.getFileName().equals(fileName)) {
fileExists = true;
break;
}
}
return fileExists;
}
private int getFreeDescriptorIndex() {
for (int i = 0; i < fileDescriptorCount; i++) {
if (fileDescriptors[i] == null) return i;
}
return -1;
}
public void open(String fileName) {
int descriptorIndex = directory.getFileDescriptorIndex(fileName);
if (descriptorIndex == -1) {
errorDrop("No such file " + fileName);
return;
}
if (oft.handlerIndex(descriptorIndex) != -1) {
errorDrop("File has been already opened.");
return;
}
int oftIndex = oft.findFreeHandler();
if (oftIndex == -1) {
return;
}
oft.getHandlers()[oftIndex] = new OpenFileTable.FileHandler();
oft.getHandlers()[oftIndex].fileDescr = descriptorIndex;
oft.getHandlers()[oftIndex].currentPosition = 0;
if (fileDescriptors[descriptorIndex].fileLen > 0) {
ByteBuffer temp = ByteBuffer.allocate(DiskIO.getBlockSize());
try {
dio.read_block(fileDescriptors[descriptorIndex].blockNumbers[0], temp);
oft.getHandlers()[oftIndex].fileBlockInBuffer = 0;
} catch (Exception e) {
e.printStackTrace();
}
oft.getHandlers()[oftIndex].currData = temp;
}
printStream.println("File " + fileName + " opened, index=" + oftIndex);
}
public void destroy(String fileName) {
int descriptorIndex = directory.getFileDescriptorIndex(fileName);
if (descriptorIndex == -1) {
errorDrop("No such file " + fileName);
return;
}
int oftIndex = oft.handlerIndex(descriptorIndex);
if (oftIndex != -1) {
closeFile(oftIndex);
}
int[] fileBlocks = fileDescriptors[descriptorIndex].blockNumbers;
for (int block : fileBlocks) {
if (block != -1) {
try {
dio.write_block(block, ByteBuffer.allocate(64));
} catch (Exception e) {
e.printStackTrace();
}
bitmap.set(block, false);
}
}
int dirEntryIndex = directory.getDirectoryEntryIndex(descriptorIndex, fileDescriptorCount);
directory.getFiles().remove(dirEntryIndex);
fileDescriptors[descriptorIndex] = null;
printStream.println("File " + fileName + " deleted");
}
public void displayDirectory() {
for (Directory.DirFile dirFile : directory.getFiles()) {
String fileName = dirFile.getFileName();
int fileLength = fileDescriptors[dirFile.getDescriptorIndex()].fileLen;
printStream.println("\t" + fileName + " <" + fileLength + ">");
}
}
public int write(int oftIndex, byte[] memArea, int count) {
if (checkOFTIndex(oftIndex) == ERR || count < 0) return ERR;
if (count == 0) {
return 0;
}
OpenFileTable.FileHandler fileHandler = oft.getHandlers()[oftIndex];
FileDescriptor fileDescriptor = fileDescriptors[fileHandler.fileDescr];
if (fileHandler.currentPosition == fileEnd) {
return 0;
}
if (saveBuffer(this, fileHandler, fileDescriptor) == ERR) return ERR;
int buffPos = fileHandler.currentPosition % DiskIO.getBlockSize();
int resPos = 0;
int writtenCount = 0;
freeData(fileHandler, fileDescriptor);
for (int i = 0; i < count && i < memArea.length; i++) {
if (buffPos == DiskIO.getBlockSize()) {
if (fileHandler.fileBlockInBuffer < 2) {
buffPos = 0;
saveBuffer(this, fileHandler, fileDescriptor);
} else {
break;
}
}
fileHandler.currData.put(buffPos, memArea[resPos]);
fileHandler.bufferModified = true;
writtenCount++;
buffPos++;
resPos++;
fileHandler.currentPosition++;
}
return writtenCount;
}
public void freeData(OpenFileTable.FileHandler fileHandler, FileDescriptor fileDescriptor) {
if (fileDescriptor.fileLen == 0) {
int newBlock = getFreeDataBlockNumber();
fileHandler.fileBlockInBuffer = 0;
fileDescriptor.blockNumbers[fileHandler.fileBlockInBuffer] = newBlock;
fileDescriptor.fileLen += DiskIO.getBlockSize();
bitmap.set(newBlock, true);
}
}
private int getFreeDataBlockNumber() {
for (int i = 8; i < 64; i++) {
if (!bitmap.get(i)) {
return i;
}
}
return -1;
}
private static int saveBuffer(FileSystem fileSystem,
OpenFileTable.FileHandler fileHandler,
FileDescriptor fileDescriptor) {
if (fileHandler.fileBlockInBuffer == -1)
return Success;
if (fileHandler.fileBlockInBuffer != (fileHandler.currentPosition / DiskIO.getBlockSize())) {
if (fileHandler.bufferModified) {
int diskBlock = fileDescriptor.blockNumbers[fileHandler.fileBlockInBuffer];
try {
fileSystem.dio.write_block(diskBlock, fileHandler.currData);
} catch (Exception e) {
e.printStackTrace();
}
}
try {
int newFileBlock = fileHandler.currentPosition / DiskIO.getBlockSize();
if (fileDescriptor.blockNumbers[newFileBlock] == -1) {
int newDiskBlock = fileSystem.getFreeDataBlockNumber();
if (newDiskBlock == -1) {
return ERR;
}
fileDescriptor.blockNumbers[newFileBlock] = newDiskBlock;
fileDescriptor.fileLen += DiskIO.getBlockSize();
fileSystem.bitmap.set(newDiskBlock, true);
}
ByteBuffer temp = ByteBuffer.allocate(DiskIO.getBlockSize());
fileSystem.dio.read_block(fileDescriptor.blockNumbers[newFileBlock], temp);
fileHandler.currData = temp;
fileHandler.bufferModified = false;
fileHandler.fileBlockInBuffer = newFileBlock;
} catch (Exception e) {
e.printStackTrace();
}
}
return Success;
}
public int read(int oftInde, ByteBuffer result, int count) {
if (checkOFTIndex(oftInde) == ERR || count < 0)
return ERR;
if (count == 0) {
return 0;
}
OpenFileTable.FileHandler fileHandler = oft.getHandlers()[oftInde];
FileDescriptor fileDescriptor = fileDescriptors[fileHandler.fileDescr];
if (isEOF(fileHandler.fileDescr) || fileDescriptor.fileLen == 0) {
return ERR;
}
if (saveBuffer(this, fileHandler, fileDescriptor) == ERR) return ERR;
int buffPos = fileHandler.currentPosition % DiskIO.getBlockSize();
int resPos = 0;
int readCount = 0;
for (int i = 0; i < count && i < result.array().length; i++) {
if (fileHandler.currentPosition == fileDescriptor.fileLen) {
break;
} else {
if (buffPos == DiskIO.getBlockSize()) {
saveBuffer(this, fileHandler, fileDescriptor);
buffPos = 0;
}
result.put(resPos, fileHandler.currData.get(buffPos));
readCount++;
buffPos++;
resPos++;
fileHandler.currentPosition++;
}
}
return readCount;
}
public static void dropDisk(String diskName, PrintStream printStream) {
File file = new File(diskName + ".txt");
if (file.delete()) {
printStream.println(diskName + " deleted");
} else {
printStream.println("Drop operation failed");
}
}
public void fileSeek(int oftInde, int pos) {
if (checkOFTIndex(oftInde) == ERR) {
errorDrop("No index " + oftInde);
return;
}
FileDescriptor fileDescriptor = fileDescriptors[oft.getHandlers()[oftInde].fileDescr];
if (pos > fileDescriptor.fileLen || pos < 0) {
errorDrop("Pos value overflow " + pos + " of [0.." + fileDescriptor.fileLen + "]");
return;
}
oft.getHandlers()[oftInde].currentPosition = pos;
printStream.println("Current position is " + oft.getHandlers()[oftInde].currentPosition);
}
private int checkOFTIndex(int oftIndex) {
if (oftIndex == ERR)
return ERR;
if (oftIndex <= 0 || oftIndex >= oft.getHandlers().length || oft.getHandlers()[oftIndex] == null)
return ERR;
return Success;
}
private boolean isEOF(int descriptorIndex) {
int fileLength = fileDescriptors[descriptorIndex].fileLen;
int position = oft.getHandlers()[oft.handlerIndex(descriptorIndex)].currentPosition;
boolean fileNotEmpty = (fileLength != 0);
boolean positionOutOfFile = (position == fileLength);
return (fileNotEmpty && positionOutOfFile);
}
private static byte[] bitsetToByteArray(BitSet bits) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < bits.size(); i++) {
if (bits.get(i)) {
stringBuilder.append('1');
} else {
stringBuilder.append('0');
}
}
for (int i = 0; i < 448; i++) {
stringBuilder.append('0');
}
return binaryStringToBytes(stringBuilder.toString());
}
private static byte[] binaryStringToBytes(String data) {
byte[] temp = new BigInteger(data, 2).toByteArray();
byte[] output = new byte[64];
System.arraycopy(temp, 1, output, 0, 64);
return output;
}
private void errorDrop(String msg) {
printStream.println("Error occurred: \n\t" + msg);
}
public static String fillToFileNameLen(String fileName) {
while (fileName.length() < Directory.maxFileName)
fileName += " ";
return fileName;
}
public static final int Success = 1;
public static final int ERR = -3;
private static final int fileEnd = 3 * DiskIO.getBlockSize();
}
| true
|
0137b13894593435e6fab1fbb22bb3fa44ddd021
|
Java
|
M2STICE/ProjetM2
|
/LireXML/src/Lire_XML_1.java
|
UTF-8
| 11,373
| 2.625
| 3
|
[
"Unlicense"
] |
permissive
|
import java.io.File;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
import org.jdom2.Document; // |
import org.jdom2.Element; // |\ Libreries
import org.jdom2.JDOMException; // |/ JDOM
import org.jdom2.input.SAXBuilder; // |
/*
* Nom de classe : Lire_XML
*
* Description: Lit un fichier xml et met l'information dans la base de données
*
* Version : 1.0
*
* Date : 09/12/2015
*
* Copyright : (C) Master 2 2015
*/
/**
* Lire_XML - Lit un fichier xml et met l'information dans la base de données
*
* @version 1.1
*
* @author CISNEROS BRIDON & HENRY
* @copyright (C) Master 2 2015
* @date 09/12/2015
* @revision 09/12
*
*/
public class Lire_XML_1 {
public static void Xml_vers_DB()
{
LinkedList <String> listEc = new LinkedList<String>();
int nb_evaluation = 0;
int nb_ec = 0;
int nb_sous_items = 0;
int nb_items = 0;
// Créer un SAXBuilder pour pouvoir parser le fichier
SAXBuilder builder = new SAXBuilder();
File xmlFile = new File("competences_1_1.xml");
try
{
String requete = new String();
// Créer un document par le biais du fichier
Document document = (Document) builder.build( xmlFile );
// On obtient la racine
Element rootNodes = document.getRootElement();
List<Element> listNodesRacine = rootNodes.getChildren("node");
Element tableRacine = (Element) listNodesRacine.get(0);
String nomDiplome = tableRacine.getAttributeValue("TEXT");
//System.out.println( "Diplome: " + nomDiplome);
String diplomeComplet = null;
// RACINE
List<Element> niveauPosition = tableRacine.getChildren("node");
Element cote_competences = (Element) niveauPosition.get(0);
//System.out.println( "Coté: " + cote_competences.getAttributeValue("TEXT"));
Element cote_syllabus = (Element) niveauPosition.get(1);
//System.out.println( "Coté: " + cote_syllabus.getAttributeValue("TEXT"));
// COTE SYLLABUS
System.out.println("\nCOTE SYLLABUS");
List<Element> liste01NiveauAIgnorerPourBD = cote_syllabus.getChildren("node");
// NIVEAU A IGNORER POUR LA BD (Fait partie du nom du diplome)
for (int u = 0; u < liste01NiveauAIgnorerPourBD.size(); u++)
{
Element niveau01AIgnorerPourBD = (Element) liste01NiveauAIgnorerPourBD.get(u);
List<Element> listeAnnees = niveau01AIgnorerPourBD.getChildren("node");
//System.out.println("(" + (u+1) + ") NIVEAU A IGNORER: " + niveau01AIgnorerPourBD.getAttributeValue("TEXT"));
diplomeComplet = nomDiplome + " " + niveau01AIgnorerPourBD.getAttributeValue("TEXT");
diplomeComplet.replace("'", "`");
requete = "insert into diplome (nom_diplome) values ('"+ diplomeComplet + "');";
requete = "select * FROM diplome ORDER BY code_diplome DESC LIMIT 1;";
for (int w = 0; w < listeAnnees.size(); w++)
{
// ANNEES
Element annees = (Element) listeAnnees.get(w);
//System.out.println("Annee: " + annees.getAttributeValue("TEXT"));
requete = "select * from annee where nom_annee = '" + annees.getAttributeValue("TEXT") + "';";
List<Element> listeSemestres = annees.getChildren("node");
for (int a = 0; a < listeSemestres.size(); a++)
{
// SEMESTRE
Element semestres = (Element) listeSemestres.get(a);
String nomSemestre = semestres.getAttributeValue("TEXT");
requete = "select * from semestre where nom_semestre = '" + nomSemestre + "';";
List<Element> listeUE = semestres.getChildren("node");
for (int b = 0; b < listeUE.size(); b++)
{
// UE
Element ue = (Element) listeUE.get(b);
//System.out.println("UE-> " + ue.getAttributeValue("TEXT"));
String nomUe = ue.getAttributeValue("TEXT").replace("'", "`");
List<Element> listeEC = ue.getChildren("node");
for (int c = 0; c < listeEC.size(); c++)
{
// EC
Element ec = (Element) listeEC.get(c);
requete = "select * FROM ue ORDER BY code_ue DESC LIMIT 1;";
//System.out.println("EC: " + ec.getAttributeValue("TEXT"));
String nomEc = ec.getAttributeValue("TEXT").replace("'", "`");
System.out.println(nomEc);
//On ajoute les nom des Ec à la liste
listEc.add(nomEc);
}
}
}
}
}
// COTE COMPETENCES
System.out.println("\nCOTE COMPETENCES");
List<Element> liste11NiveauAIgnorerPourBD = cote_competences.getChildren("node");
// NIVEAU A IGNORER POUR LA BD
for (int i = 0; i < liste11NiveauAIgnorerPourBD.size(); i++)
{
Element niveau11AIgnorerPourBD = (Element) liste11NiveauAIgnorerPourBD.get(i);
List<Element> listeDomaines = niveau11AIgnorerPourBD.getChildren("node");
//System.out.println("(" + (i+1) + ") NIVEAU A IGNORER: "+ niveau11AIgnorerPourBD.getAttributeValue("TEXT"));
diplomeComplet = nomDiplome + " " + niveau11AIgnorerPourBD.getAttributeValue("TEXT");
requete = "select * from diplome where nom_diplome = '" + diplomeComplet + "';";
for (int j = 0; j < listeDomaines.size(); j++)
{
// DOMAINE
Element domaine = (Element) listeDomaines.get(j);
String nomDomaine = domaine.getAttributeValue("TEXT").replace("'", "`");
//System.out.println("Nom domaine: " + nomDomaine);
requete = "select * FROM domaine ORDER BY code_domaine DESC LIMIT 1;";
List<Element> listeCompetences = domaine.getChildren("node");
for (int k = 0; k < listeCompetences.size(); k++)
{
// DOMAINES DE COMPETENCE
Element competences = (Element) listeCompetences.get(k);
String nomCompetence = competences.getAttributeValue("TEXT").replace("'", "`");
//System.out.println("Competence: " + competences.getAttributeValue("TEXT"));
List<Element> listeItems = competences.getChildren("node");
for (int f = 0; f < listeItems.size(); f++)
{
nb_items ++;
// ITEMS
Element items = (Element) listeItems.get(f);
String nomItem = items.getAttributeValue("TEXT").replace("'", "`");
//System.out.println("Item: " + items.getAttributeValue("TEXT"));
List<Element> liste12NiveauAIgnorerPourBD = items.getChildren("node");
for (int t = 0; t < liste12NiveauAIgnorerPourBD.size(); t++)
{
// NIVEAU A IGNORER POUR LA BD
Element niveau12AIgnorerPourBD = (Element) liste12NiveauAIgnorerPourBD.get(t);
String nomEcC = niveau12AIgnorerPourBD.getAttributeValue("TEXT").replace("'", "`");
//nomEcC = nomEcC.replace("´", "`");
nomEcC = nomEcC.substring(5);
System.out.println("EC: "+ nomEcC);
//Si l'Ec est présent dans la liste des Ec alors on ajoute les sous-items et les évaluations associés
if(listEc.indexOf(nomEcC)!=-1)
{ nb_ec++;
requete = "select * from Ec where nom_ec = '" + nomEcC.toLowerCase() + "'";
List<Element> listeSousItems = niveau12AIgnorerPourBD.getChildren("node");
for (int h = 0; h < listeSousItems.size(); h++)
{
// SOUS-ITEMS
Element sousItems = (Element) listeSousItems.get(h);
String nomSousItem = sousItems.getAttributeValue("TEXT").replace("'", "`");
System.out.println("Sous-items: " + sousItems.getAttributeValue("TEXT"));
nb_sous_items++;
requete = "insert into sous_item (nom_sous_item) values ('" + nomSousItem + "');";
requete = "select * FROM sous_item ORDER BY code_sous_item DESC LIMIT 1;";
List<Element> listeEvaluations = sousItems.getChildren("node");
//System.out.println("Taille : "+ listeEvaluations.size());
for (int x = 0; x < listeEvaluations.size(); x++)
{
// EVALUATIONS
Element evaluations = (Element) listeEvaluations.get(x);
if (evaluations.getAttributeValue("TEXT") != null)
{
//System.out.println(evaluations.getAttributeValue("TEXT"));
String nomEvaluation = evaluations.getAttributeValue("TEXT").replace("'", "`");
//System.out.println("Evaluations: " + evaluations.getAttributeValue("TEXT"));
nb_evaluation ++;
requete = "insert into evaluation (nom_evaluation) values ('" + nomEvaluation + "');";
}
}
}
}
}
}
}
}
}
System.out.println("Nombre items: "+nb_items);
System.out.println("Nombre EC sélectionné: "+nb_ec);
System.out.println("Nombre sous items sélectionné: "+nb_sous_items);
System.out.println("Nombre evaluation sélectionnée:" +nb_evaluation);
}catch ( IOException io ) {
System.out.println( io.getMessage() );
}catch ( JDOMException jdomex ) {
System.out.println( jdomex.getMessage() );
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Xml_vers_DB();
}
}
| true
|
749a5aced5adaeaecef7c3008ede2838f4f33149
|
Java
|
hernanponcedeleon/Dat3M
|
/dartagnan/src/test/java/com/dat3m/dartagnan/c/IMMTest.java
|
UTF-8
| 3,070
| 2.09375
| 2
|
[
"MIT"
] |
permissive
|
package com.dat3m.dartagnan.c;
import com.dat3m.dartagnan.configuration.Arch;
import com.dat3m.dartagnan.parsers.cat.ParserCat;
import com.dat3m.dartagnan.utils.Result;
import com.dat3m.dartagnan.utils.rules.CSVLogger;
import com.dat3m.dartagnan.utils.rules.Provider;
import com.dat3m.dartagnan.verification.solving.AssumeSolver;
import com.dat3m.dartagnan.verification.solving.RefinementSolver;
import com.dat3m.dartagnan.wmm.Wmm;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import static com.dat3m.dartagnan.configuration.Arch.IMM;
import static com.dat3m.dartagnan.utils.ResourceHelper.CAT_RESOURCE_PATH;
import static com.dat3m.dartagnan.utils.ResourceHelper.TEST_RESOURCE_PATH;
import static com.dat3m.dartagnan.utils.Result.FAIL;
import static com.dat3m.dartagnan.utils.Result.PASS;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class IMMTest extends AbstractCTest {
public IMMTest(String name, Arch target, Result expected) {
super(name, target, expected);
}
@Override
protected Provider<String> getProgramPathProvider() {
return Provider.fromSupplier(() -> TEST_RESOURCE_PATH + "imm/" + name + ".bpl");
}
@Override
protected long getTimeout() {
return 60000;
}
@Override
protected Provider<Wmm> getWmmProvider() {
return Provider.fromSupplier(() -> new ParserCat().parse(new File(CAT_RESOURCE_PATH + "cat/imm.cat")));
}
@Parameterized.Parameters(name = "{index}: {0}, target={1}")
public static Iterable<Object[]> data() throws IOException {
return Arrays.asList(new Object[][]{
{"paper-E3.1", IMM, PASS},
{"paper-E3.2", IMM, PASS},
{"paper-E3.3", IMM, PASS},
{"paper-E3.4", IMM, PASS},
{"paper-E3.5", IMM, PASS},
{"paper-E3.6", IMM, FAIL},
{"paper-E3.7", IMM, PASS},
{"paper-E3.8", IMM, PASS},
{"paper-E3.8-alt", IMM, FAIL},
{"paper-E3.9", IMM, PASS},
{"paper-E3.10", IMM, PASS},
{"paper-R2", IMM, PASS},
// IMM from the paper returns PASS in the test bewow.
// But since we follow the sw definition of RC11, the
// expected result is FAIL (confirmed by genMC)
{"paper-R2-alt", IMM, FAIL},
});
}
@Test
@CSVLogger.FileName("csv/assume")
public void testAssume() throws Exception {
AssumeSolver s = AssumeSolver.run(contextProvider.get(), proverProvider.get(), taskProvider.get());
assertEquals(expected, s.getResult());
}
@Test
@CSVLogger.FileName("csv/refinement")
public void testRefinement() throws Exception {
RefinementSolver s = RefinementSolver.run(contextProvider.get(), proverProvider.get(), taskProvider.get());
assertEquals(expected, s.getResult());
}
}
| true
|
d4de8a92730bf9a7cd3881790b0a934dbbb3846a
|
Java
|
fbr-hyh/LibInfoSys
|
/src/main/java/edu/nju/libInfoSys/Service/UserInfoServiceImpl.java
|
UTF-8
| 2,151
| 2.359375
| 2
|
[] |
no_license
|
package edu.nju.libInfoSys.Service;
import edu.nju.libInfoSys.Dao.UserInfoDao;
import edu.nju.libInfoSys.Entity.BorrowRecord;
import edu.nju.libInfoSys.Entity.OverduePenaltyRecord;
import edu.nju.libInfoSys.Entity.RecordEntity;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
public class UserInfoServiceImpl implements UserInfoService {
@Autowired
UserInfoDao userInfoDao;
// @Override
// public ArrayList<BorrowRecord> getAllBorrowReport() {
// return null;
// }
//
// @Override
// public ArrayList<OverduePenaltyRecord> getAllOverduePenalty() {
// return null;
// }
@Override
public ArrayList<BorrowRecord> getBorrowReportByUserId(String userId) {
ArrayList<BorrowRecord> borrowRecords = new ArrayList<>();
ArrayList<RecordEntity> recordEntities = userInfoDao.getReportsByUserId(userId);
int i = 0;
for (RecordEntity recordEntity : recordEntities) {
borrowRecords.add(new BorrowRecord(i, recordEntity.getBookId(), recordEntity.getUserId(), recordEntity.getBorrowTime(), recordEntity.getReturnTime(), recordEntity.getRecordStatus()));
i++;
}
return borrowRecords;
}
@Override
public ArrayList<OverduePenaltyRecord> getOverduePenaltyReportByUserId(String userId) {
ArrayList<OverduePenaltyRecord> overduePenaltyRecords = new ArrayList<>();
ArrayList<RecordEntity> recordEntities = userInfoDao.getOverdueReportsByUserId(userId);
int i = 0;
for (RecordEntity recordEntity : recordEntities) {
overduePenaltyRecords.add(new OverduePenaltyRecord(i, recordEntity.getUserId(), recordEntity.getBookId(), recordEntity.getReturnTime(), recordEntity.getOverduePenalty()));
i++;
}
return overduePenaltyRecords;
}
@Override
public double getOverduePenaltyByUserId(String userId) {
return userInfoDao.getOverduePenaltyByUserId(userId);
}
@Override
public void modifyPassword(String userId, String newPassword) {
userInfoDao.modifyPassword(userId, newPassword);
}
}
| true
|
0963c9801ad2775f6e5da9f57673b60fd43aa8e9
|
Java
|
GMOD/Chado
|
/XMLTools/GameChadoConv/CTG.java
|
UTF-8
| 1,629
| 2.59375
| 3
|
[] |
no_license
|
//CTG.java
import conv.chadxtogame.GameWriter;
import java.io.*;
import java.util.*;
public class CTG {
public static void main(String argv []) {
String infile=null,outfile=null;
int DistStart = 0;
int DistEnd = 0;
//boolean geneOnly = false;
int readMode = GameWriter.CONVERT_ALL;
String NewSeqName = null;
for(int i=0;i<argv.length;i++){
if(argv[i]!=null){
if(argv[i].startsWith("-")){
if(argv[i].startsWith("-D")){
String d = argv[i].substring(2);
StringTokenizer stok = new StringTokenizer(d,",");
if(stok.hasMoreTokens()){
String ds = stok.nextToken();
try{
DistStart = Integer.decode(ds).intValue();
}catch(Exception ex){
}
}
if(stok.hasMoreTokens()){
String ds = stok.nextToken();
try{
DistEnd = Integer.decode(ds).intValue();
}catch(Exception ex){
}
}
if(stok.hasMoreTokens()){
NewSeqName = stok.nextToken();
}
}else if(argv[i].startsWith("-a")){
//geneOnly = true;
readMode = GameWriter.CONVERT_ALL;
}else if(argv[i].startsWith("-g")){
//geneOnly = true;
readMode = GameWriter.CONVERT_GENE;
}else if(argv[i].startsWith("-c")){
//geneOnly = true;
readMode = GameWriter.CONVERT_COMP;
}
}else{
if(infile==null){//FIRST
infile = argv[i];
}else if(outfile==null){//SECOND
outfile = argv[i];
}
}
}
}
GameWriter rd = new GameWriter(infile,outfile,DistStart,DistEnd,NewSeqName,readMode);
rd.ChadoToGame();
}
}
| true
|
bc83daf0770102698520853f929cdad612c72649
|
Java
|
VishalDutt1998/DSA-1
|
/Java Foundation/Generic Tree/NodeWithMaximumSubtreeSum.java
|
UTF-8
| 2,025
| 3.828125
| 4
|
[] |
no_license
|
public class NodeWithMaximumSubtreeSum {
public static class Node {
int data;
ArrayList<Node> children;
public Node() {
this.data = 0;
this.children = new ArrayList<>();
}
public Node(int data) {
this.data = data;
this.children = new ArrayList<>();
}
}
public static Node construct(Integer[] arr) {
Node root = null;
Stack<Node> st = new Stack<>();
for (int i = 0; i < arr.length; i++) {
Integer data = arr[i];
if (data != null) {
Node nn = new Node(data);
if (st.size() == 0) {
root = nn;
st.push(nn);
} else {
st.peek().children.add(nn);
st.push(nn);
}
} else {
st.pop();
}
}
return root;
}
public static void display(Node root) {
String str = "[" + root.data + "] -> ";
for (Node child : root.children) {
str += child.data + ", ";
}
System.out.println(str + " .");
for (int i = 0; i < root.children.size(); i++) {
Node child = root.children.get(i);
display(child);
}
}
// Node with maximum Subtree Sum
static int nodeData = 0;
static int omax = Integer.MIN_VALUE;
public static int treeSum(Node node) {
int sum = 0;
for (Node child : node.children) {
sum += treeSum(child);
}
sum += node.data;
if (sum > omax) {
nodeData = node.data;
omax = sum;
}
return sum;
}
public static int treeSum2(Node node) {
int sum = 0;
for (Node child : node.children) {
sum += treeSum2(child);
}
sum += node.data;
System.out.println(node.data + " @ " + sum);
return sum;
}
}
| true
|
ff099a584093e96a7e1a4096e5dc3d5d020e1c17
|
Java
|
motazEmad/interview-test
|
/src/main/java/com/travix/medusa/busyflights/service/BusyFlightWS.java
|
UTF-8
| 1,729
| 2.09375
| 2
|
[] |
no_license
|
package com.travix.medusa.busyflights.service;
import static org.springframework.http.ResponseEntity.ok;
import java.util.List;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.travix.medusa.busyflights.domain.busyflights.BusyFlightsRequest;
import com.travix.medusa.busyflights.domain.busyflights.BusyFlightsResponse;
import com.travix.medusa.busyflights.exceptions.BusyFlightsException;
import com.travix.medusa.busyflights.service.toughJet.ToughJetServiceWrapper;
@RestController
@RequestMapping("/busyFlight")
public class BusyFlightWS {
private static final Logger logger = LoggerFactory.getLogger(BusyFlightWS.class);
@Autowired
private List<? extends ServiceProviderWrapper> serviceProvidersList;
@PostMapping("/searchFlights")
public ResponseEntity<List<BusyFlightsResponse>> search(@RequestBody BusyFlightsRequest request) {
List<BusyFlightsResponse> result = serviceProvidersList.stream().map(serviceProvider -> {
try {
return serviceProvider.searchFlights(request);
} catch (BusyFlightsException e) {
logger.error("failed to search for service Provider " + serviceProvider.getClass(), e);
}
return null;
}).collect(Collectors.toList());
return ok(result);
}
}
| true
|
838e9dc887ce10e40f3b71c24581c8cf1f1c5b54
|
Java
|
moutainhigh/cn-appoint-demo
|
/cn-appoint-service/src/main/java/com/jd/appoint/service/shop/impl/ShopFormControlItemServiceImpl.java
|
UTF-8
| 11,782
| 1.828125
| 2
|
[] |
no_license
|
package com.jd.appoint.service.shop.impl;
import com.alibaba.fastjson.PropertyNamingStrategy;
import com.google.common.collect.Maps;
import com.jd.appoint.api.vo.VenderConfigVO;
import com.jd.appoint.common.security.LocalSecurityClient;
import com.jd.appoint.dao.shop.ShopFormControlItemDao;
import com.jd.appoint.domain.enums.EncryptTypeEnum;
import com.jd.appoint.domain.order.AppointOrderFormItemPO;
import com.jd.appoint.domain.shop.ShopFormControlItemPO;
import com.jd.appoint.domain.shop.query.FormControlItemQuery;
import com.jd.appoint.rpc.jmi.dto.IdentityDTO;
import com.jd.appoint.rpc.jmi.jicc.RpcIdentityService;
import com.jd.appoint.service.order.vo.ValueFromControlItem;
import com.jd.appoint.service.shop.IdcardUtil;
import com.jd.appoint.service.shop.ShopFormControlItemService;
import com.jd.appoint.service.sys.VenderConfigConstant;
import com.jd.appoint.service.sys.VenderConfigService;
import com.jd.appoint.vo.order.AppointOrderDetailVO;
import com.jd.jmi.jicc.client.enums.JICCPapersTypeEnum;
import org.apache.commons.collections4.CollectionUtils;
import org.elasticsearch.common.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
/**
* Created by yangyuan on 5/15/18.
*/
@Service
public class ShopFormControlItemServiceImpl implements ShopFormControlItemService {
@Autowired
private ShopFormControlItemDao shopFormControlItemDao;
@Autowired
private RpcIdentityService rpcIdentityService;
@Autowired
private VenderConfigService venderConfigService;
@Autowired
private LocalSecurityClient localSecurityClient;
private final Map<String, Method> APPOINT_ORDER_READ_METHOD_MAP = Maps.newHashMap();
private Logger logger = LoggerFactory.getLogger(ShopFormControlItemServiceImpl.class);
@PostConstruct
public void init() {
PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(AppointOrderDetailVO.class);
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
if (propertyDescriptor.getReadMethod() != null) {
APPOINT_ORDER_READ_METHOD_MAP.put(propertyDescriptor.getName(), propertyDescriptor.getReadMethod());
}
}
}
@Override
public List<ShopFormControlItemPO> query(FormControlItemQuery formControlItemQuery) {
return shopFormControlItemDao.query(formControlItemQuery);
}
@Override
public List<ShopFormControlItemPO> queryByBusinessCode(String businessCode) {
return shopFormControlItemDao.queryByBusinessCode(businessCode);
}
@Override
@Transactional
public boolean batchInsert(List<ShopFormControlItemPO> itemPOList) {
if (CollectionUtils.isNotEmpty(itemPOList)) {
return shopFormControlItemDao.batchInsert(itemPOList) > 0;
}
return false;
}
@Override
public void insert(ShopFormControlItemPO shopFormControlItemPO) {
shopFormControlItemDao.insert(shopFormControlItemPO);
}
@Override
public boolean update(ShopFormControlItemPO shopFormControlItemPO) {
return shopFormControlItemDao.update(shopFormControlItemPO) > 0;
}
@Override
public void delete(Long id) {
shopFormControlItemDao.delete(id);
}
@Override
public Map<String, ValueFromControlItem> createValueMap(AppointOrderDetailVO appointOrderDetailVo) throws IllegalArgumentException {
if (appointOrderDetailVo.getFormItems() == null) {//初始化
appointOrderDetailVo.setFormItems(Maps.newHashMap());
}
Map<String, ValueFromControlItem> result = createSimpleValueMap(appointOrderDetailVo.getFormItems(), appointOrderDetailVo.getBusinessCode(), appointOrderDetailVo.getServerType());
//参数合法校验
valid(result.values(), appointOrderDetailVo);
//加密
encrypt(result.values());
dealIdentity(result, appointOrderDetailVo);
return result;
}
private void dealIdentity(Map<String, ValueFromControlItem> result, AppointOrderDetailVO appointOrderDetailVo) {
Optional<ValueFromControlItem> identityNumOption = result.values().stream()
.filter(item -> item.getEncryptType() == EncryptTypeEnum.JMI_ENCRYPT)
.findFirst();
if (identityNumOption.isPresent()) {
ValueFromControlItem identity = identityNumOption.get();
IdentityDTO identityDTO = this.createIdentityDTO(identity, appointOrderDetailVo);
validIdentityDTO(identityDTO);
//调用户簿
String identityId = rpcIdentityService.addUserIdentity(identityDTO);
identity.setAttrValue(identityId);
result.put(identity.getAttrNameAlias(), identity);
}
}
@Override
public Map<String, EncryptTypeEnum> queryEncryptByBusinessCode(String businessCode) {
List<ShopFormControlItemPO> itemPOS = this.shopFormControlItemDao.queryByBusinessCode(businessCode);
Map<String, EncryptTypeEnum> result = itemPOS.stream()
.collect(Collectors.toMap(ShopFormControlItemPO::getAlias, ShopFormControlItemPO::getEncryptType));
return result;
}
@Override
public List<ShopFormControlItemPO> findByBusinessCodeAndPageNoAndVenderId(String businessCode, String pageNo, Long venderId) {
return shopFormControlItemDao.findByBusinessCodeAndPageNoAndVenderId(businessCode, pageNo, venderId);
}
private Map<String, ValueFromControlItem> createSimpleValueMap(Map<String, String> formItems, String businessCode, Integer serverType) {
List<ShopFormControlItemPO> shopFormControlItemPOS = this.queryByBusinessCode(businessCode);
Map<String, ValueFromControlItem> result = shopFormControlItemPOS.stream()//表单控制要求的，即使没有填值也需要构建到result中以便于之后校验
.filter(shopFormControlItemPO -> {
if (serverType == 1) {
return shopFormControlItemPO.getOnSiteDisplay();
} else {
return shopFormControlItemPO.getToShopDisplay();
}
})
//转变成ValueFromControlItem
.map(shopFormControlItemPO -> convertValueFromControlItem(shopFormControlItemPO, formItems.get(shopFormControlItemPO.getAlias())))
//to map
.collect(Collectors.toMap(valueItem -> valueItem.getAttrNameAlias(), valueItem -> valueItem));
return result;
}
private void validIdentityDTO(IdentityDTO identityDTO) throws IllegalArgumentException {
if (identityDTO.getCertType() == JICCPapersTypeEnum.IDENTITY && !IdcardUtil.isIdCard(identityDTO.getCertNum())) {
throw new IllegalArgumentException("身份证号码校验失败，当前身份证号:" + identityDTO.getCertNum());
}
}
/**
* 加密
*
* @param values
*/
private void encrypt(Collection<ValueFromControlItem> values) {
values.stream()
.filter(item -> item.getEncryptType() == EncryptTypeEnum.SAFETY_ENCRYPT)//只处理本地加密
.forEach(item -> item.setAttrValue(localSecurityClient.encrypt(item.getAttrValue())));
}
/**
* 合法校验
*
* @param values
* @param detailVO
* @throws IllegalArgumentException
*/
private void valid(Collection<ValueFromControlItem> values, AppointOrderDetailVO detailVO) throws IllegalArgumentException {
values.stream().filter(item -> item.isOrderFiled())//处理静态属性
.forEach(item -> {
//配置为静态属性，但是没有getMethod
if (!APPOINT_ORDER_READ_METHOD_MAP.containsKey(item.getAttrNameAlias())) {
throw new IllegalArgumentException(item.getAttrNameAlias() + "为静态属性，但是AppointOrderDetailVO中没用次属性，请修改配置");
}
Method getMethod = APPOINT_ORDER_READ_METHOD_MAP.get(item.getAttrNameAlias());
try {
Object value = getMethod.invoke(detailVO);
if (value != null) {
if (value instanceof Date) {
value = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format((Date) value);
}
item.setAttrValue(value.toString());
}
} catch (Exception e) {
logger.error("AppointOrderDetailVO.{}方法执行报错", getMethod.getName(), e);
}
});
values.stream().forEach(item -> {
if (item.isNeedInput() && Strings.isNullOrEmpty(item.getAttrValue())) {
throw new IllegalArgumentException(item.getAttrNameAlias() + "为必填项，当前未填写");
}
if (!Strings.isNullOrEmpty(item.getRegular())) {//如果需要正则校验
boolean isOk = Pattern.matches(item.getRegular(), item.getAttrValue() == null ? "" : item.getAttrValue());
if (!isOk) {
throw new IllegalArgumentException(item.getAttrNameAlias() + "校验失败，校验正则表达式：" + item.getRegular() + "，实际值：" + item.getAttrValue());
}
}
});
}
private IdentityDTO createIdentityDTO(ValueFromControlItem identity, AppointOrderDetailVO detailVo) {
IdentityDTO identityDTO = new IdentityDTO();
if (Strings.isNullOrEmpty(detailVo.getCustomerName())) {
throw new IllegalArgumentException("customerName is null");
}
identityDTO.setName(detailVo.getCustomerName());
identityDTO.setCertNum(identity.getAttrValue());
VenderConfigVO config = venderConfigService.getConfig(detailVo.getBusinessCode(), detailVo.getVenderId(), VenderConfigConstant.IDENTITY_KEY);
if (config == null || Strings.isNullOrEmpty(config.getKey())) {
throw new IllegalStateException("配置表" + VenderConfigConstant.IDENTITY_KEY
+ "未配置,业务类型：" + detailVo.getBusinessCode()
+ "venderId:" + detailVo.getVenderId());
}
//获取证件类型别名
String identityTypeAlias = config.getKey();
//证件类型
String identityType = detailVo.getFormItems().get(identityTypeAlias);
identityDTO.setCertType(JICCPapersTypeEnum.ExistEnum(Integer.parseInt(identityType)));
return identityDTO;
}
private ValueFromControlItem convertValueFromControlItem(ShopFormControlItemPO shopFormControlItemPO, String value) {
ValueFromControlItem valueFromControlItem = new ValueFromControlItem();
valueFromControlItem.setAttrNameAlias(shopFormControlItemPO.getAlias());
valueFromControlItem.setAttrValue(value);
valueFromControlItem.setFormControlId(shopFormControlItemPO.getId());
valueFromControlItem.setRegular(shopFormControlItemPO.getRegular());
valueFromControlItem.setNeedInput(shopFormControlItemPO.getNeedInput());
valueFromControlItem.setOrderFiled(shopFormControlItemPO.getOrderField());
return valueFromControlItem;
}
}
| true
|
826e991b325dbf5d582261c5bd222cf057c0d34a
|
Java
|
849298831/wx-manager
|
/src/main/java/com/example/manager/wxmanager/service/RepairService.java
|
UTF-8
| 397
| 1.757813
| 2
|
[
"MIT"
] |
permissive
|
package com.example.manager.wxmanager.service;
import com.example.manager.wxmanager.model.RepairModel;
import com.example.manager.wxmanager.model.common.ResultModel;
import com.github.pagehelper.PageInfo;
public interface RepairService {
ResultModel add(RepairModel repairModel);
ResultModel update(RepairModel repairModel);
PageInfo<RepairModel> query(RepairModel repairModel);
}
| true
|
a4fb57144af6b244d74ea0d60ff6a2bb3c9ea8c5
|
Java
|
SwipeX/OSBA
|
/src/com/bool/graph/FlowGraph.java
|
UTF-8
| 2,038
| 2.625
| 3
|
[] |
no_license
|
package com.bool.graph;
import com.bool.asm.BasicBlock;
import com.bool.asm.MethodNode;
import org.jgrapht.DirectedGraph;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.graph.SimpleDirectedGraph;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
/**
* Created with IntelliJ IDEA.
* User: Jeroen
* Date: 27-2-13
* Time: 15:54
*/
public class FlowGraph {
private MethodNode mn;
public FlowGraph(MethodNode mn) {
this.mn = mn;
}
public DirectedGraph<BasicBlock, DefaultEdge> getGraph() {
DirectedGraph<BasicBlock, DefaultEdge> g = new SimpleDirectedGraph<BasicBlock, DefaultEdge>(DefaultEdge.class);
for (BasicBlock ain : mn.basicBlocks) {
//System.out.println(ain);
if (!g.containsVertex(ain)) {
g.addVertex(ain);
}
if(ain.getTarget() != null && ain.getTarget() != ain){
if (!g.containsVertex(ain.getTarget())) {
g.addVertex(ain.getTarget());
}
g.addEdge(ain, ain.getTarget());
}
if (ain.getNext() != null) {
if (!g.containsVertex(ain.getNext())) {
g.addVertex(ain.getNext());
}
g.addEdge(ain, ain.getNext());
}
}
/*AbstractInsnNode ain = mn.instructions.getFirst();
while (ain != null) {
AbstractInsnNode next = ain.getNext();
if (next != null) {
if(ain.getOpcode() != Opcodes.GOTO)
g.addEdge(ain, next);
if(ain instanceof JumpInsnNode){
g.addEdge(ain, ((JumpInsnNode) ain).label);
}
} else if(ain.getOpcode() == Opcodes.GOTO){
g.addEdge(ain, ((JumpInsnNode)ain).label);
}
ain = ain.getNext();
} */
return g;
}
}
| true
|
d7a4d278007ecd0d8e8f4a354dd4371b69e97223
|
Java
|
Jason1989/jeestudio
|
/jeeStudio/src/com/zxt/compplatform/authority/dao/RoleDao.java
|
UTF-8
| 4,138
| 2.25
| 2
|
[] |
no_license
|
package com.zxt.compplatform.authority.dao;
import java.util.List;
import com.zxt.compplatform.authority.entity.OrgRole;
import com.zxt.compplatform.authority.entity.Role;
import com.zxt.compplatform.authority.entity.RoleUser;
import com.zxt.compplatform.organization.entity.TOrganization;
/**
* 角色
* 数据持久化操作
* @author 007
*/
public interface RoleDao{
/**
* 查询所有角色与部门无关带分页
*
*/
public List findRoleAllList(int rows,int page);
/**
* 查询当前用户未选中的角色
*
*/
public List findRoleAllList(int rows,int page,String userId);
/**
* 添加组织机构与角色关系
*/
public void addOrgRole(OrgRole or);
/**
* 角色数目
* @return
*/
public int findRoleAllNum();
/**
* 查询当前用户未添加的角色
* @param userId
* @return
*/
public int findRoleAllNum(String userId);
/**
* 查找所有角色
*/
public List findAllRole();
/**
* 查询角色列表
*/
public List roleListPag(int page,int rows);
/**
* 查询角色列表 带参数
*/
public List roleListPagWithParam(int page,int rows,String rname);
/**
* 查询角色列表 带参数
*/
public List roleListPagWithParam(int page,int rows,String rname,String userId);
//**********************************************************
/**
* 用户列表(特定角色下的用户列表)
*/
public List ListUserUnderRole(int page,int rows,String rid);
/**
* 查询特定角色下的用户条数
*/
public int findTotalRowsUnderRole(String rid);
/**
* 查询角色功能
*/
public String findRFunction(String rname);
//**********************************************************
/**
* 查询角色总条数
*/
public int findTotalRows();
/**
* 查询角色总条数 带参数
*/
public int findTotalRowsWithParam(String rname);
/**
* 查询角色总条数 带参数
*/
public int findTotalRowsWithParam(String rname,String userId);
/**
* 删除角色
* @param id
*/
public void deleteRole(String id);
/**
* 添加级别(级别ID为查询出的最大值加1)
* 添加组织结构与角色之间关系
*/
public void addRole(Role role,OrgRole or);
/**
* 添加级别(级别ID为查询出的最大值加1)
*/
public void addRole(Role role);
/**
* 查询角色ID最大值
*/
public int findMaxId();
/**
* 判断角色是否存在(添加时)
*/
public List isExist(String name);
/**
* 判断角色是否存在(修改时)
*/
public int isExist(Role role);
/**
* 根据角色id查出所在部门机构的信息
*/
public TOrganization findOrgByRoId(String id );
/**
* 修改角色
*/
public void updateRole(Role role,OrgRole oldor,OrgRole or);
/**
* 根据id查询特定角色
*/
public Role findRoleById(String id);
/**
* 查询特定角色下是否有用户
*/
public List isExistUser(String id);
/**
* 查找某个角色下的用户
*/
public List findUserByRoleId(String id);
//*****************角色修改用户************
/**
* 查询角色用户表中的最大值
*/
public int findMaxIDFromRole_User();
/**
* 给角色用户表添加信息
*/
public void addUserToRole(RoleUser roleuser);
/**
* 判断要添加的用户是否重复
*/
public List isExistUserInRoleUser(String rid,String uid);
/**
* 删除角色下的特定用户
*/
public void deletUserUnderRole(String rid, String uid);
//************************************************************
/**
* 获取所有用户
* @param page
* @param rows
* @param oid
* @param username
* @param uname
* @return
*/
public List getAllUserForCommon(int page, int rows, String oid ,String username, String uname);;
/**
* 查询某个用户下的角色的总数
* @param oid
* @param username
* @param uname
* @return
*/
public int userTotalCount(String oid, String username ,String uname);
//*********************************************************
/**
* 查询某个用户下的角色
* @param userid
* @return
*/
public List getRoleListUnderUser(String userid);
}
| true
|
158d98dc874f0e1db7be7c22d71ddcdf31c78f3f
|
Java
|
APPsist/pki-connector
|
/src/main/java/de/appsist/service/pki/model/ProcessInstance.java
|
UTF-8
| 1,432
| 2.484375
| 2
|
[] |
no_license
|
package de.appsist.service.pki.model;
import org.vertx.java.core.json.JsonObject;
/**
* Model for process instances.
* @author simon.schwantzer(at)im-c.de
*/
public class ProcessInstance {
private final JsonObject json;
public ProcessInstance(JsonObject json) throws IllegalArgumentException {
validateJson(json);
this.json = json;
}
private static void validateJson(JsonObject json) throws IllegalArgumentException {
String id = json.getString("id");
if (id == null || id.trim().isEmpty()) {
throw new IllegalArgumentException("Invalid or missing [id].");
}
String processId = json.getString("id");
if (processId == null || processId.trim().isEmpty()) {
throw new IllegalArgumentException("Missing or invalid process identifier [processId].");
}
Boolean isRunning = json.getBoolean("isRunning");
if (isRunning == null) {
throw new IllegalArgumentException("Missing running information [isRunning].");
}
}
public JsonObject asJson() {
return json;
}
public String getId() {
return json.getString("id");
}
public String getProcessId() {
return json.getString("processId");
}
public boolean isRunning() {
return json.getBoolean("isRunning");
}
public String getUserId() {
return json.getString("userId");
}
public String getParent() {
return json.getString("parent");
}
public JsonObject getContext() {
return json.getObject("context");
}
}
| true
|
5734ae6f660dcac49acd5101471f058a2e3499de
|
Java
|
SPuerBRead/Bridge
|
/src/main/java/bridge/mapper/WeblogMapper.java
|
UTF-8
| 1,059
| 2.03125
| 2
|
[] |
no_license
|
package bridge.mapper;
import bridge.model.WebLog;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface WeblogMapper {
@Insert("insert into weblog(id,host,time,ip,path,header,method,params,data,logid,version) values(#{id},#{host},#{time},#{ip},#{path},#{header},#{method},#{params},#{data},#{logid},#{version})")
void insert(WebLog webLog);
@Select("select * from weblog where host like concat('%',#{0},'%') order by time desc")
List<WebLog> getAll(String host);
@Delete("delete from weblog where id=#{id}")
void deleteOneByID(String id);
@Delete("delete from weblog where logid=#{logid}")
void deleteAllBylogID(int logid);
@Select("select * from weblog where id = #{id} limit 1")
WebLog selectWeblogByID(String id);
@Select("select * from weblog where host = #{host}")
List<WebLog> selectWebLogByHost(String host);
}
| true
|
edd1a5ba81834bac5f485fac6cfc21b0961fe4e6
|
Java
|
magic-coder/huawei-wear-re
|
/src/com/huawei/pluginaf500/ui/bi.java
|
UTF-8
| 773
| 1.765625
| 2
|
[] |
no_license
|
package com.huawei.pluginaf500.ui;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
/* compiled from: ResetBraceletActivity */
class bi extends BroadcastReceiver {
final /* synthetic */ ResetBraceletActivity f19929a;
bi(ResetBraceletActivity resetBraceletActivity) {
this.f19929a = resetBraceletActivity;
}
public void onReceive(Context context, Intent intent) {
if ("com.fenda.hwbracelet.INTENT_FACTORY_RESET".equals(intent.getAction())) {
this.f19929a.sendBroadcast(new Intent("com.fenda.hwbracelet.intent.prevent.reconnect"), "com.af500.permission.MYBRODCAST");
new Handler().postDelayed(new bj(this), 8000);
}
}
}
| true
|
ed82848a65f9cc47ad3e23d846dbee7b0b77bd05
|
Java
|
gartdan/supplier-collaboration
|
/supplier-service/src/main/java/com/jci/supplier/azure/AzureStorage.java
|
UTF-8
| 1,608
| 2.25
| 2
|
[] |
no_license
|
package com.jci.supplier.azure;
import java.net.URISyntaxException;
import java.security.InvalidKeyException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.microsoft.azure.storage.CloudStorageAccount;
import com.microsoft.azure.storage.StorageException;
import com.microsoft.azure.storage.table.CloudTable;
import com.microsoft.azure.storage.table.CloudTableClient;
public class AzureStorage {
private static final Logger LOG = LoggerFactory.getLogger(AzureStorage.class);
private static final String FORMAT = "DefaultEndpointsProtocol=%s;AccountName=%s;AccountKey=%s";
private String protocol;
private String accountName;
private String accountKey;
public AzureStorage(String protocol, String accountName, String accountKey) {
this.protocol = protocol;
this.accountName = accountName;
this.accountKey = accountKey;
}
public final String getStoregeConnectionString() {
// LOG.info(" ### Starting Ending AzureStorage.getStoregeConnectionString ###");
return String.format(FORMAT, protocol, accountName, accountKey);
}
public CloudTable getTable(String tableName) throws InvalidKeyException, URISyntaxException, StorageException {
//LOG.info(" ### Starting Ending AzureStorage.getTable ### "+tableName);
return CloudStorageAccount.parse(getStoregeConnectionString()).createCloudTableClient().getTableReference(tableName);
}
public CloudTableClient getInstance() throws InvalidKeyException, URISyntaxException, StorageException {
return CloudStorageAccount.parse(getStoregeConnectionString()).createCloudTableClient();
}
}
| true
|
97176e5fa29f3aa828029f7aec0ecc54bbf5dc8c
|
Java
|
abecedarianlq/lq
|
/Emp.java
|
UTF-8
| 103
| 1.859375
| 2
|
[] |
no_license
|
public class Emp implements java.io.Serializable{
private Integer empno ;
private String ename ;
}
| true
|
2f020076c39a554343045582ee3f3ace3c2ff7ee
|
Java
|
AyshaIfra/Medihub
|
/src/java/com/medihub/hospital/HospitalView.java
|
UTF-8
| 2,266
| 2.21875
| 2
|
[] |
no_license
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.medihub.hospital;
import com.medihub.db.DbConfig;
import com.medihub.user.User;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
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 javax.servlet.http.HttpSession;
/**
*
* @author Yash
*/
@WebServlet(name = "HospitalView", urlPatterns = {"/hospitalview"})
public class HospitalView extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
int hospitalAdminId =Integer.parseInt(session.getAttribute("userid").toString());
PrintWriter out = response.getWriter();
try
{
DbConfig db = DbConfig.getInstance();
Connection con = db.getConnecton();
Statement stmt=con.createStatement();
ResultSet rs=stmt.executeQuery("SELECT hospital_id FROM hospital_admins WHERE user_id="+hospitalAdminId);
int hospitalId=1;
while(rs.next()){
hospitalId=rs.getInt("hospital_id");
}
Hospital h = new Hospital(hospitalId);
User u = new User(hospitalAdminId);
request.setAttribute("profile", u.getProfile());
request.setAttribute("hospitalprofile", h.getHospital(hospitalId));
request.getRequestDispatcher("viewhospital.jsp").forward(request, response);
}catch(Exception e){
out.println(e.toString());
}
}
@Override
public String getServletInfo() {
return "Short description";
}// </editor-fold>
}
| true
|
f08ff5231d1badca84a114e3ddd02ce1b2cf8da0
|
Java
|
CaoWenCool/pattern
|
/prototype/src/main/java/com/demo/prototype/shallow/Prototype.java
|
UTF-8
| 188
| 1.945313
| 2
|
[] |
no_license
|
package com.demo.prototype.shallow;
/**
* @author: Maniac Wen
* @create: 2020/4/23
* @update: 7:53
* @version: V1.0
* @detail:
**/
public interface Prototype {
Prototype clone();
}
| true
|
1dacc25919708f2fff3ec4eca87346a6dbea8ee9
|
Java
|
UpTownCat/spring-boot-park-car
|
/src/main/java/com/example/bean/specification/ParkingPlaceSpecification.java
|
UTF-8
| 2,299
| 2.453125
| 2
|
[] |
no_license
|
package com.example.bean.specification;
import com.example.bean.ParkingPlace;
import com.example.util.CommonUtils;
import org.springframework.data.jpa.domain.Specification;
import javax.persistence.criteria.*;
/**
* Created by Administrator on 2017/7/21.
*/
public class ParkingPlaceSpecification implements Specification<ParkingPlace> {
private String name;
private String location;
private String left;
private String right;
@Override
public Predicate toPredicate(Root<ParkingPlace> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
if(!CommonUtils.isEmpty(name)) {
Path<String> namePath = root.get("name");
query.where(cb.like(namePath, "%" + name + "%"));
}
if(!CommonUtils.isEmpty(location)) {
Path<String> locationPath = root.get("location");
query.where(cb.like(locationPath, "%" + location + "%"));
}
if(!CommonUtils.isEmpty(left) && CommonUtils.isEmpty(right)) {
Path<Double> moneyPerHourPath = root.get("moneyPerHour");
query.where(cb.greaterThanOrEqualTo(moneyPerHourPath, Double.parseDouble(left)));
}
if(CommonUtils.isEmpty(left) && !CommonUtils.isEmpty(right)) {
Path<Double> moneyPerHourPath = root.get("moneyPerHour");
query.where(cb.lessThanOrEqualTo(moneyPerHourPath, Double.parseDouble(right)));
}
if(!CommonUtils.isEmpty(left) && !CommonUtils.isEmpty(right)) {
Path<Double> moneyPerHourPath = root.get("moneyPerHour");
query.where(cb.between(moneyPerHourPath, Double.parseDouble(left), Double.parseDouble(right)));
}
return null;
}
public String getName() {
return name;
}
public ParkingPlaceSpecification() {
}
public void setName(String name) {
this.name = name;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public String getLeft() {
return left;
}
public void setLeft(String left) {
this.left = left;
}
public String getRight() {
return right;
}
public void setRight(String right) {
this.right = right;
}
}
| true
|
bbc697715d3201ee259d9f422a74d1ed2ffa6a83
|
Java
|
Woutderoy/mavenfx
|
/src/main/java/nl/inholland/javafx/models/Customer.java
|
UTF-8
| 261
| 2.15625
| 2
|
[] |
no_license
|
package nl.inholland.javafx.models;
public class Customer extends User{
public Customer(String firstName, String lastName, String userName, String passWord, String accessLevel) {
super(firstName, lastName, userName, passWord, accessLevel);
}
}
| true
|
6319b49905d697179c1aa11378ccd914b7f1d568
|
Java
|
RiyaadC/TPAssignment4
|
/TPAssignmet4/Question3/PLK/src/main/java/PLKGood/Second.java
|
UTF-8
| 192
| 2.421875
| 2
|
[] |
no_license
|
package PLKGood;
/**
* Created by Riyaad on 3/29/2017.
*/
public class Second
{
public String Message()
{
Third thir = new Third();
return thir.Message();
}
}
| true
|
b7f00cf8c58c43c0e724c7c274dea67baa0878c6
|
Java
|
djpeng/pengdaijun-demo
|
/springmvc.generic/src/main/java/com/pengdaijun/demo/springmvc/generic/service/PersonService.java
|
UTF-8
| 646
| 2.234375
| 2
|
[] |
no_license
|
package com.pengdaijun.demo.springmvc.generic.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.pengdaijun.demo.springmvc.generic.dao.IPersonDao;
import com.pengdaijun.demo.springmvc.generic.entity.PersonModel;
@Service
public class PersonService extends AbstractBaseService<PersonModel, Long> implements IPersonService {
@Autowired
IPersonDao personDao;
@Override
public void customeSvcMethod1(PersonModel model) {
personDao.customeDaoMethod1(model);
}
@Override
public PersonModel customeSvcMehtod2() {
return personDao.customeDaoMehtod2();
}
}
| true
|
e55a49cb4d8b4b3bae5db0feada0c0616e0f4fa4
|
Java
|
monkeykingGWX/learn_springmvc
|
/s_annotaion01/src/main/java/com/annotation/factory/FruitFactoryBean.java
|
UTF-8
| 545
| 2.609375
| 3
|
[
"MIT"
] |
permissive
|
package com.annotation.factory;
import com.annotation.bean.Fruit;
import org.springframework.beans.factory.FactoryBean;
public class FruitFactoryBean implements FactoryBean {
private String name;
public Object getObject() throws Exception {
System.out.println("create fruit");
return new Fruit(name);
}
public Class<?> getObjectType() {
return Fruit.class;
}
public boolean isSingleton() {
return true;
}
public void setName(String name) {
this.name = name;
}
}
| true
|
c6cc9a1eeb5de730fb11ed0798e405f4ce8ea8f3
|
Java
|
vattay/connection_pool_scaffold
|
/src/test/java/co/txrx/tidal/TestConnectionPool.java
|
UTF-8
| 10,535
| 2.6875
| 3
|
[] |
no_license
|
package co.txrx.tidal;
import static org.junit.Assert.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Stack;
import java.util.concurrent.TimeoutException;
import org.junit.*;
public class TestConnectionPool {
// Create an in-memory named instance of an h2 database'
// Delay destroying DB until VM is destroyed.
final static String dataSourceUrl = "jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1";
//final static String dataSourceUrl = "jdbc:mysql://localhost/test";
final static String user = "testuser";
final static String password = "...Zappo141!";
ConnectionPoolConfig config;
@BeforeClass
public static void createDb() throws SQLException{
Connection conn = DriverManager.getConnection(dataSourceUrl,user,password);
setupDb(conn);
}
@Before
public void setupConfig(){
config = new ConnectionPoolConfig();
config.setDataSourceUrl(dataSourceUrl);
config.setUser(user);
config.setPassword(password);
config.setInitIdle(2);
config.setMaxIdle(4);
config.setMaxTotal(8);
config.setTimeOut(5);
}
@org.junit.Test
public void initializePool() throws SQLException{
final int configIdleInit = 100;
config.setInitIdle(configIdleInit);
config.setMaxIdle(configIdleInit);
ConnectionPool tidalCp = new ConnectionPool(config);
int idleConns = tidalCp.getIdleCount();
assertEquals("Initial connection count", configIdleInit, idleConns );
tidalCp.terminate();
}
@org.junit.Test
public void queryBasic() throws SQLException{
final int configIdleInit = 1;
config.setInitIdle(configIdleInit);
config.setMaxIdle(configIdleInit);
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
simpleQuery(conn);
tidalCp.releaseConnection(conn);
int idleConns = tidalCp.getIdleCount();
assertEquals("Idle count", configIdleInit, idleConns );
tidalCp.terminate();
}
@org.junit.Test
public void releaseBasic() throws SQLException{
final int configIdleInit = 1;
config.setInitIdle(configIdleInit);
config.setMaxIdle(configIdleInit);
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.releaseConnection(conn);
int idleConns = tidalCp.getIdleCount();
assertEquals("Idle count", configIdleInit, idleConns );
tidalCp.terminate();
}
@org.junit.Test
public void releaseZerosize() throws SQLException{
final int configIdleInit = 0;
config.setInitIdle(configIdleInit);
config.setMaxIdle(configIdleInit);
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.releaseConnection(conn);
assertEquals("Idle count", configIdleInit, tidalCp.getIdleCount() );
tidalCp.terminate();
}
@org.junit.Test
public void idleExhaust() throws SQLException{
final int configIdleInit = 10;
final int configIdleMax = 10;
final int overflow = 10;
config.setInitIdle(configIdleInit);
config.setMaxIdle(configIdleMax);
config.setMaxTotal(configIdleMax + overflow);
config.setTimeOut(4);
Stack<Connection> connStack = new Stack<Connection>();
ConnectionPool tidalCp = new ConnectionPool(config);
for (int i = 0; i < config.getMaxIdle() + overflow; i++){
Connection conn = tidalCp.getConnection();
connStack.push(conn);
}
assertEquals( "Connection count", overflow + config.getMaxIdle(), tidalCp.getConnectionCount());
for (int i = 0; i < config.getMaxIdle() + overflow; i++){
Connection conn = connStack.pop();
tidalCp.releaseConnection(conn);
}
assertEquals( "Active Connection count after", 0, tidalCp.getActiveCount());
assertEquals( "Idle count", config.getMaxIdle(), tidalCp.getIdleCount() );
tidalCp.terminate();
}
@org.junit.Test
public void exhaustTotalConnections() throws Throwable{
final int configIdleInit = 2;
final int overflow = 2;
final int configMaxTotal = 3;
final int configTimeout = 1;
config.setInitIdle(configIdleInit);
config.setMaxIdle(configIdleInit);
config.setMaxTotal(configMaxTotal);
config.setTimeOut(configTimeout);
Stack<Connection> connStack = new Stack<Connection>();
ConnectionPool tidalCp = new ConnectionPool(config);
try {
for (int i = 0; i < config.getMaxTotal() + overflow; i++){
Connection conn = tidalCp.getConnection();
connStack.push(conn);
}
}catch(SQLException e) {
assertEquals( e.getCause().getClass() , TimeoutException.class );
}
assertEquals("Exhaustion limit.", config.getMaxTotal(), tidalCp.getConnectionCount());
while(!connStack.empty()){
Connection conn = connStack.pop();
tidalCp.releaseConnection(conn);
}
int idleConns = tidalCp.getIdleCount();
assertEquals( "Resume max idle.", config.getMaxIdle(), idleConns );
tidalCp.terminate();
}
@org.junit.Test
public void shutdownBasic() throws SQLException{
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.releaseConnection(conn);
tidalCp.shutdown();
assertEquals( 0, tidalCp.getIdleCount() );
tidalCp.terminate();
}
@org.junit.Test (expected=IllegalStateException.class)
public void shutdownReuse() throws SQLException{
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.releaseConnection(conn);
tidalCp.shutdown();
conn = tidalCp.getConnection();
assertEquals( 0, tidalCp.getIdleCount() );
tidalCp.terminate();
}
@org.junit.Test (expected=IllegalStateException.class)
public void terminationReuse() throws SQLException{
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.releaseConnection(conn);
tidalCp.terminate();
conn = tidalCp.getConnection();
assertEquals( 0, tidalCp.getConnectionCount() );
tidalCp.terminate();
}
@org.junit.Test
public void releasePathalogical() throws SQLException{
final int idle = 5;
config.setInitIdle(idle);
config.setMaxIdle(idle);
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.releaseConnection(conn);
tidalCp.releaseConnection(conn);
tidalCp.releaseConnection(conn);
tidalCp.releaseConnection(conn);
assertEquals("Idle Count", idle, tidalCp.getIdleCount() );
tidalCp.terminate();
}
@org.junit.Test
public void shutdownReuseQuery() throws SQLException{
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.shutdown();
simpleQuery(conn);
tidalCp.releaseConnection(conn);
assertEquals("Connection count 0", 0, tidalCp.getConnectionCount());
tidalCp.terminate();
}
@org.junit.Test (expected=SQLException.class)
public void terminateReuseConnQuery() throws SQLException{
ConnectionPool tidalCp = new ConnectionPool(config);
Connection conn = tidalCp.getConnection();
tidalCp.terminate();
simpleQuery(conn);
tidalCp.releaseConnection(conn);
assertEquals("Connection count 0", 0, tidalCp.getConnectionCount());
tidalCp.terminate();
}
@org.junit.Test
public void randomUse() throws SQLException, InterruptedException{
final int iterations = 100;
final int idle = 5;
final int maxActive = 10;
int connCount = 0;
config.setInitIdle(idle);
config.setMaxIdle(idle);
config.setMaxTotal(maxActive);
config.setTimeOut(5);
Stack<Connection> connStack = new Stack<Connection>();
ConnectionPool tidalCp = new ConnectionPool(config);
connStack.push(tidalCp.getConnection());
connCount++;
for (int i = 0; i < iterations; i++){
Thread.sleep(10);
if ( !connStack.empty() ) { simpleQuery(connStack.peek()); }
if (Math.random() > 0.5) {
if ((connCount) < maxActive){
//System.out.println( "connCount = " + connCount);
connStack.push(tidalCp.getConnection());
connCount++;
}
}else{
if (!connStack.isEmpty()){
tidalCp.releaseConnection(connStack.pop());
connCount--;
}
}
}
assertEquals("Connection Count", connCount, tidalCp.getActiveCount());
assertTrue("Idle Count", idle >= tidalCp.getIdleCount());
assertTrue("Active Count", maxActive >= tidalCp.getConnectionCount());
tidalCp.terminate();
}
@org.junit.Test
public void concurrentRandom() throws SQLException, InterruptedException{
final int iterations = 100;
final int threads = 100;
final int idle = 100;
final int maxActive = 100;
config.setInitIdle(idle);
config.setMaxIdle(idle);
config.setMaxTotal(maxActive);
config.setTimeOut(5);
ConnectionPool tidalCp = new ConnectionPool(config);
Stack<Thread> threadStack = new Stack<Thread>();
long start = System.nanoTime();
for (int i = 0; i < threads; i++){
PoolHammer hammer = new PoolHammer(tidalCp,iterations,0);
Thread t = new Thread(hammer);
t.start();
threadStack.push(t);
}
while (!threadStack.isEmpty()){
assertTrue("Idle Count", idle >= tidalCp.getIdleCount());
Thread t = threadStack.pop();
t.join();
}
long finish = System.nanoTime();
System.out.println("Core exec time = " + (finish-start) / 1000 / 1000);
assertTrue("Idle Count", idle >= tidalCp.getIdleCount());
tidalCp.terminate();
}
@org.junit.Test
public void shutdownFlag() throws SQLException{
ConnectionPool tidalCp = new ConnectionPool(config);
tidalCp.shutdown();
assertTrue(tidalCp.isShutdown());
tidalCp.terminate();
}
private void simpleQuery(Connection conn) throws SQLException{
Statement stmt = null;
ResultSet rs = null;
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM Test");
rs.first();
while (!rs.isAfterLast()) {
//System.out.println(rs.getString(2));
rs.next();
}
rs.close();
stmt.close();
}
private static void setupDb(Connection conn) throws SQLException{
Statement stmt = conn.createStatement();
stmt.executeUpdate("DROP TABLE IF EXISTS Test");
stmt.executeUpdate("CREATE TABLE Test (Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(255)) ");
stmt.executeUpdate("INSERT INTO Test (Name) VALUES ('opower')");
stmt.executeUpdate("INSERT INTO Test (Name) VALUES ('obama')");
stmt.executeUpdate("INSERT INTO Test (Name) VALUES ('energy')");
stmt.executeUpdate("INSERT INTO Test (Name) VALUES ('efficiency')");
}
}
| true
|
e3194f1b965226a1d630da56725b8a033a8058cc
|
Java
|
jarekpawlowski/SpareParts
|
/Spareparts/SpareParts/src/main/java/com/sparepartswarehouse/entity/producent/ProducentRepository.java
|
UTF-8
| 1,091
| 2.328125
| 2
|
[] |
no_license
|
package com.sparepartswarehouse.entity.producent;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository("producentRepository")
public class ProducentRepository {
@Autowired
Producent producent;
@PersistenceContext
EntityManager entityManager;
@Transactional
public Producent findProducent(int Prod_ID) {
Producent prod = entityManager.find(Producent.class, Prod_ID);
return prod;
}
@Transactional
public Producent createProducent(String prodName) {
Producent producent = new Producent();
producent.setProducentNazwa(prodName);
entityManager.merge(producent);
return producent;
}
@Transactional
public Producent createProducentPersist(String prodName) {
Producent producent = new Producent();
producent.setProducentNazwa(prodName);
entityManager.persist(producent);
return producent;
}
}
| true
|
765bb52faa8965caf770b8280982fcd4dee16179
|
Java
|
stackroute/boeing-w1-matchmaker
|
/project-microservice/src/main/java/com/stackroute/matchmaker/relationshipmodel/SkillRelationshipProperties.java
|
UTF-8
| 766
| 2.53125
| 3
|
[] |
no_license
|
package com.stackroute.matchmaker.relationshipmodel;
import org.springframework.beans.factory.annotation.Autowired;
public class SkillRelationshipProperties {
private String weight;
private String skills;
@Autowired
public SkillRelationshipProperties(String weight, String skills) {
super();
this.weight = weight;
this.skills = skills;
}
public SkillRelationshipProperties() {
}
public String getWeight() {
return weight;
}
public void setWeight(String weight) {
this.weight = weight;
}
public String getSkills() {
return skills;
}
public void setSkills(String skills) {
this.skills = skills;
}
@Override
public String toString() {
return "SkillRelationshipProperties [weight=" + weight + ", skills=" + skills + "]";
}
}
| true
|
c4c6449a1998437014767faa1e3888d286b8c7c7
|
Java
|
ZLBer/DaliyOfProgramme
|
/src/main/java/leetcode/leet738.java
|
UTF-8
| 2,008
| 3.484375
| 3
|
[] |
no_license
|
package leetcode;
public class leet738 {
//贪就完了
/* public int monotoneIncreasingDigits(int N) {
char[] chars = (N + "").toCharArray();
StringBuilder sb=new StringBuilder();
int pre=-1;
boolean flag=false;
for (int i = 0; i < chars.length; i++) {
if(flag==true){
sb.append(9);
continue;
}
if(chars[i]>=pre){
sb.append(chars[i]);
pre=chars[i];
}else {
char c=sb.charAt(sb.length()-1);
while (sb.length()>0&&sb.charAt(sb.length()-1)==c){
sb.deleteCharAt(sb.length()-1);
i--;
}
sb.append((char)(chars[i]-1));
flag=true;i--;
}
}
return Integer.valueOf(sb.toString());
}*/
//别人的貌似简单多了 哈哈哈 思想是一样的
public int monotoneIncreasingDigits(int N) {
char[] arr = (N + "").toCharArray();
int max = -1, idx = -1;
for (int i = 0; i < arr.length - 1; i++) {
if (max < arr[i]) {
max = arr[i];
idx = i;
}
if (arr[i] > arr[i + 1]) {
arr[idx] -= 1;
for(int j = idx + 1;j < arr.length;j++) {
arr[j] = '9';
}
break;
}
}
return Integer.parseInt(new String(arr));
}
//好家伙
//简单说一下理解
//就像叠罗汉一样 在保证递增的情况下在9次之内一定可以达到最大
// 1111
// 111
// 11
// 1
/* public int monotoneIncreasingDigits(int N) {
int ones = 111111111;
int res = 0;
for(int i=0;i<9;i++){
while(res+ones>N){
ones/=10;
}
res += ones;
if(ones==0)
break;
}
return res;
}
*/
}
| true
|
92f1ac8be3f8b02d63746ec658fde6f013eb49fd
|
Java
|
lazluaw/egovframe
|
/test/src/main/java/com/test/web/proxies/UserProxy.java
|
UTF-8
| 1,118
| 2.625
| 3
|
[] |
no_license
|
package com.test.web.proxies;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.test.web.mappers.TxMapper;
@Component //("user") //다른데선 user라는 객체 이름으로 써야만 진입 가능(manager이 될 수도 있음)
public class UserProxy extends Proxy {
@Autowired TxMapper txMapper;
//통계
//더미데이터로 만들 걸 이렇게 만들고 메서드를 계속 돌리면 계속 생성됨
public String makeBirthday() {
String birthday = "";
return birthday;
}
public String makeGender() {
List<String> genderText = Arrays.asList("M", "F");
Collections.shuffle(genderText); //섞임
return genderText.get(0);
}
public String makeUserId() {
List<String> userIdText = Arrays.asList("a", "b"); //아이디에 맞는 문자열을 한땀한땀 넣어서 하기
Collections.shuffle(userIdText);
return userIdText.get(0);
}
public String makeName() {
return "";
}
public String makeTelephone() {
return "";
}
}
| true
|
722a3b33374e2e89d0f220321550b21ebbb22d9d
|
Java
|
shafighi/Library
|
/src/java/Forms/FilesDetails.java
|
UTF-8
| 1,466
| 2.453125
| 2
|
[] |
no_license
|
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package Forms;
/**
*
* @author shadi
*/
public class FilesDetails {
private String name=null;
private String path=null;
private String show=null;
private String type=null;
private String levelone=null;
private String accept = null;
public FilesDetails(String name,String path ,String show,String type,String levelone) {
setName((name));
setLevelone((levelone));
setPath((path));
setShow((show));
setType((type));
}
public FilesDetails() {
}
public String getAccept() {
return accept;
}
public void setAccept(String accept) {
this.accept = (accept);
}
public String getLevelone() {
return levelone;
}
public void setLevelone(String levelone) {
this.levelone =(levelone);
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = (path);
}
public String getShow() {
return show;
}
public void setShow(String show) {
this.show = (show);
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = (type);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = (name);
}
}
| true
|
0206765186ca4c03f10e6ce06e46e075698d4157
|
Java
|
vmanriquec/Empresadelivery
|
/app/src/main/java/com/empresadelivery/empresadelivery/modelos/CruddescuentosRealm.java
|
UTF-8
| 472
| 2.109375
| 2
|
[] |
no_license
|
package com.empresadelivery.empresadelivery.modelos;
import io.realm.Realm;
public class CruddescuentosRealm {
public final static int calculateIndex(){
Realm realm = Realm.getDefaultInstance();
Number currentIdNum = realm.where(DescuentosRealm.class).max("iddesc");
int nextId;
if(currentIdNum == null){
nextId = 0;
}else {
nextId = currentIdNum.intValue()+1;
}
return nextId;
}
}
| true
|
d440f6a1aaf0c93508aa53bf41d20b9307526976
|
Java
|
Gigadrive/DungeonRPG
|
/src/main/java/net/wrathofdungeons/dungeonrpg/regions/RegionData.java
|
UTF-8
| 208
| 1.695313
| 2
|
[] |
no_license
|
package net.wrathofdungeons.dungeonrpg.regions;
import net.wrathofdungeons.dungeonrpg.dungeon.DungeonType;
public class RegionData {
public DungeonType dungeonType;
public boolean isBoss = false;
}
| true
|
c78c679cbee42fa40c927a13b054d136432ab2e1
|
Java
|
carlosmizabi/Dominoes-CW
|
/dominoes/DominoesExtended.java
|
UTF-8
| 1,052
| 3.015625
| 3
|
[] |
no_license
|
package dominoes;
import dominoes.players.DominoPlayer;
public class DominoesExtended extends Dominoes {
private DominoPlayer[] players;
private DominoPlayer player2;
private DominoUI ui;
private int points;
public DominoesExtended(DominoUI ui, DominoPlayer player1,
DominoPlayer player2, int points, int pips)
{
super(ui, player1, player2, points, pips);
players = new DominoPlayer[2];
this.players[0] = player1;
this.players[1] = player2;
this.ui = ui;
this.points = points;
}
public int numPlayersHands()
{
int hand1 = 0, hand2 = 0;
try{ hand1 = players[0].numInHand();}
catch(NullPointerException enull){ }
try{ hand2 = players[1].numInHand();}
catch(NullPointerException enull){ }
return hand1 + hand2;
}
/**
* @return DominoPlayer[] game players
*/
public DominoPlayer[] getPlayers(){ return this.players; }
/**
* @return DominoUI
*/
public DominoUI getUI(){ return this.ui; }
/**
* @return game points target
*/
public int getPoints(){ return this.points; }
}
| true
|
afd2b58f0c6839c7a743507274004faa9b7a34f7
|
Java
|
rbaci99/PreviousCode
|
/Cse214hw5Email/src/email/SubjectComparator.java
|
UTF-8
| 313
| 2.6875
| 3
|
[] |
no_license
|
package email;
/**
* Class to represent
* @author Robert Bacigalupo,112145826,Rec.01
*/
import java.util.Comparator;
public class SubjectComparator implements Comparator<Email> {
@Override
public int compare(Email email1,Email email2) {
return email1.getSubject().compareTo(email2.getSubject());
}
}
| true
|
2040b3f05fa2931c19620567589027b864c893b5
|
Java
|
luyanjie/game-acgneta
|
/game-acgneta-comment/src/main/java/com/tongbu/game/dao/dynamics/UserDynamicsNoShowDao.java
|
UTF-8
| 725
| 1.984375
| 2
|
[] |
no_license
|
package com.tongbu.game.dao.dynamics;
import com.tongbu.game.entity.dynamics.DynamicsNoShow;
import com.tongbu.game.entity.dynamics.DynamicsShow;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import java.util.List;
public interface UserDynamicsNoShowDao extends MongoRepository<DynamicsNoShow,String> {
/**
* 根据用户id获取动态数据
* @param uid 用户id
* @return List
*/
List<DynamicsShow> findByUid(int uid);
@Query(value = "{'uid':?0}")
Page<DynamicsShow> findByUid(int uid, Pageable pageable);
}
| true
|
d89d9b405e102a201bd03e59993c83f8a6766ab1
|
Java
|
liuxiujava/game_qp
|
/game-qp/src/x/vo/util/CommonStringUtil.java
|
UTF-8
| 1,134
| 2.640625
| 3
|
[] |
no_license
|
package x.vo.util;
import java.util.ArrayList;
import java.util.List;
public class CommonStringUtil {
public static List<CommonInfo> splitString(String str) {
List<CommonInfo> list = new ArrayList<>();
if (str == null || str.equals("") || str.equals("0")) {
return list;
}
String[] result = str.split(";");
for (String s : result) {
String[] r = s.split(",");
list.add(new CommonInfo(Integer.parseInt(r[0]), Integer.parseInt(r[1])));
}
return list;
}
public static String mergeString(List<CommonInfo> list) {
StringBuilder result = new StringBuilder();
for (CommonInfo str : list) {
result.append(str.getId()).append(",");
result.append(str.getValue()).append(";");
}
return result.toString();
}
public static String mergeString(CommonInfo commonInfo) {
StringBuilder result = new StringBuilder();
result.append(commonInfo.getId()).append(",");
result.append(commonInfo.getValue()).append(";");
return result.toString();
}
}
| true
|
b5215a3894b87a0e4a4337f217d9d33a3cf3d7fb
|
Java
|
infinispan/infinispan
|
/core/src/main/java/org/infinispan/util/logging/events/EventLogSerializer.java
|
UTF-8
| 1,289
| 2.203125
| 2
|
[
"Apache-2.0",
"LicenseRef-scancode-dco-1.1"
] |
permissive
|
package org.infinispan.util.logging.events;
import java.util.Optional;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.configuration.serializing.ConfigurationSerializer;
/**
* @since 14.0
*/
public class EventLogSerializer implements ConfigurationSerializer<EventLog> {
@Override
public void serialize(ConfigurationWriter writer, EventLog event) {
writer.writeStartElement("log");
writer.writeAttribute("category", event.getCategory().name());
writer.writeStartElement("content");
writer.writeAttribute("level", event.getLevel().name());
writer.writeAttribute("message", event.getMessage());
writer.writeAttribute("detail", unwrap(event.getDetail()));
writer.writeEndElement();
writer.writeStartElement("meta");
writer.writeAttribute("instant", event.getWhen().toString());
writer.writeAttribute("context", unwrap(event.getContext()));
writer.writeAttribute("scope", unwrap(event.getScope()));
writer.writeAttribute("who", unwrap(event.getWho()));
// `meta` object
writer.writeEndElement();
// `log` object
writer.writeEndElement();
}
private String unwrap(Optional<String> optional) {
return optional.orElse(null);
}
}
| true
|
526e4f10ade2f34cdfbac1e8557fc714b66f2269
|
Java
|
weitat95/mastersDissertation
|
/qardio_source/cfr_dec/com/mixpanel/android/java_websocket/exceptions/IncompleteHandshakeException.java
|
UTF-8
| 421
| 2.171875
| 2
|
[] |
no_license
|
/*
* Decompiled with CFR 0.147.
*/
package com.mixpanel.android.java_websocket.exceptions;
public class IncompleteHandshakeException
extends RuntimeException {
private int newsize;
public IncompleteHandshakeException() {
this.newsize = 0;
}
public IncompleteHandshakeException(int n) {
this.newsize = n;
}
public int getPreferedSize() {
return this.newsize;
}
}
| true
|
7836c5d9919d367c037fdf8480f9b93e4cd82320
|
Java
|
ToluFash/StockKeeper-Java
|
/src/com/stockkeeper/Views/uicomponents/PurchasesPanel.java
|
UTF-8
| 7,572
| 2.65625
| 3
|
[] |
no_license
|
package com.stockkeeper.Views.uicomponents;
import com.stockkeeper.Controller.Global;
import com.stockkeeper.Views.uicomponents.fancytextinput.OpenIcon;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;
import java.awt.event.MouseListener;
public class PurchasesPanel extends JPanel implements Details{
private JLabel title;
private JLabel product;
private JLabel qty;
private JLabel entrySize;
private JLabel supplier;
private JLabel time;
private JPanel details;
private JPanel graphPanel;
private OneByTwoRow productP;
private OneByTwoRow qtyP;
private OneByTwoRow titleP;
private OneByTwoRow entrySizeP;
private OneByTwoRow supplierP;
private OneByTwoRow timeP;
private OneByTwoRow taxPayableP;
private OpenIcon openIcon;
public PurchasesPanel(JLabel product, JLabel qty, JLabel title, JLabel entrySize, JLabel supplier, JLabel time) {
setPreferredSize(new Dimension(400,600));
setLayout(new FlowLayout(FlowLayout.LEFT));
setBackground(Global.colorScheme.getTertiaryColor());
details = new JPanel(new FlowLayout(FlowLayout.LEFT));
details.setOpaque(false);
details.setPreferredSize(new Dimension(400,200));
add(details);
this.product = product;
this.qty = qty;
this.title = title;
this.entrySize = entrySize;
this.supplier = supplier;
this.time = time;
openIcon = new OpenIcon();
JPanel titlePanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
titlePanel.setPreferredSize( new Dimension(400,25));
titlePanel.setOpaque(false);
titlePanel.add((new JLabel("Details:"){
@Override
public Font getFont() {
return FontsList.getHelvetica(Font.BOLD, 15);
}
@Override
public Dimension getPreferredSize() {
return new Dimension(350,25);
}
}));
openIcon = new OpenIcon();
titlePanel.add(openIcon);
details.add(titlePanel);
this.productP = new OneByTwoRow(new JLabel("Product:"){
@Override
public Dimension getPreferredSize() {
return new Dimension(80,25);
}
@Override
public Font getFont() {
return FontsList.getHelvetica(Font.BOLD, 12);
}
}, this.product){
@Override
public Dimension getPreferredSize() {
return new Dimension(400,25);
}
};
this.qtyP = new OneByTwoRow(new JLabel("Quantity Sold:"){
@Override
public Dimension getPreferredSize() {
return new Dimension(80,25);
}
@Override
public Font getFont() {
return FontsList.getHelvetica(Font.BOLD, 12);
}
}, this.qty){
@Override
public Dimension getPreferredSize() {
return new Dimension(400,25);
}
};
this.titleP = new OneByTwoRow(new JLabel("Ticket No:"){
@Override
public Dimension getPreferredSize() {
return new Dimension(80,25);
}
@Override
public Font getFont() {
return FontsList.getHelvetica(Font.BOLD, 12);
}
}, this.title){
@Override
public Dimension getPreferredSize() {
return new Dimension(400,25);
}
};
this.entrySizeP = new OneByTwoRow(new JLabel("Size:"){
@Override
public Dimension getPreferredSize() {
return new Dimension(80,25);
}
@Override
public Font getFont() {
return FontsList.getHelvetica(Font.BOLD, 12);
}
}, this.entrySize){
@Override
public Dimension getPreferredSize() {
return new Dimension(400,25);
}
};
this.supplierP = new OneByTwoRow(new JLabel("Supplier:"){
@Override
public Dimension getPreferredSize() {
return new Dimension(80,20);
}
@Override
public Font getFont() {
return FontsList.getHelvetica(Font.BOLD, 12);
}
}, this.supplier){
@Override
public Dimension getPreferredSize() {
return new Dimension(400,25);
}
};
this.timeP = new OneByTwoRow(new JLabel("Time:"){
@Override
public Dimension getPreferredSize() {
return new Dimension(80,25);
}
@Override
public Font getFont() {
return FontsList.getHelvetica(Font.BOLD, 12);
}
}, this.time){
@Override
public Dimension getPreferredSize() {
return new Dimension(400,25);
}
};
this.graphPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
graphPanel.setPreferredSize(new Dimension(380,300));
graphPanel.setBackground(Global.colorScheme.getTertiaryColor());
details.add(productP);
details.add(qtyP);
details.add(titleP);
details.add(entrySizeP);
details.add(supplierP);
details.add(timeP);
add(graphPanel);
setBorder(new EmptyBorder(10,0,0,2));
}
@Override
public synchronized void addMouseListener(MouseListener l) {
openIcon.addMouseListener(l);
super.addMouseListener(l);
}
public OpenIcon getOpenIcon() {
return openIcon;
}
public JLabel getTitle() {
return title;
}
public void setTitle(JLabel title) {
this.title = title;
}
public JLabel getEntrySize() {
return entrySize;
}
public void setEntrySize(JLabel entrySize) {
this.entrySize = entrySize;
}
public JLabel getSupplier() {
return supplier;
}
public void setSupplier(JLabel supplier) {
this.supplier = supplier;
}
public JLabel getTime() {
return time;
}
public void setTime(JLabel time) {
this.time = time;
}
public JPanel getDetails() {
return details;
}
public void setDetails(JPanel details) {
this.details = details;
}
public void setDetailsVisible(Boolean visible){
details.setVisible(visible);
}
public void switchView(int switchType){
switch (switchType){
case 1:
productP.setVisible(true);
qtyP.setVisible(true);
titleP.setVisible(false);
entrySizeP.setVisible(false);
supplierP.setVisible(false);
timeP.setVisible(false);
break;
case 2:
productP.setVisible(false);
qtyP.setVisible(false);
titleP.setVisible(true);
entrySizeP.setVisible(true);
supplierP.setVisible(true);
timeP.setVisible(true);
break;
}
}
public void setTicketDetailsVisible(Boolean visible){
details.setVisible(visible);
}
public JPanel getGraphPanel() {
return graphPanel;
}
public void setGraphPanel(JPanel graphPanel) {
this.graphPanel = graphPanel;
}
}
| true
|
e9c06d0c2385ef4759d09f7c1db67d411d1c26a8
|
Java
|
Birkenstab/gugusto
|
/src/de/thu/gpro/gugusto/scene/scenes/leveleditor/editor/LevelEditorMenu.java
|
UTF-8
| 1,040
| 2.34375
| 2
|
[] |
no_license
|
package de.thu.gpro.gugusto.scene.scenes.leveleditor.editor;
import de.thu.gpro.gugusto.game.Game;
import de.thu.gpro.gugusto.scene.scenes.leveleditor.selection.LevelEditorSelectionScene;
import de.thu.gpro.gugusto.scene.scenes.startmenu.StartMenuScene;
import de.thu.gpro.gugusto.ui.components.Menu;
class LevelEditorMenu extends Menu {
private LevelEditorAction levelEditorAction;
public LevelEditorMenu(LevelEditorAction levelEditorAction){
super();
this.levelEditorAction = levelEditorAction;
addMenuEntry("Save Map", e -> {
levelEditorAction.save();
setVisible(false);
});
addMenuEntry("Save and Exit", e -> {
levelEditorAction.save();
Game.getInstance().getSceneManager().setScene(new StartMenuScene());
});
addMenuEntry("Back to Level Selection", e -> Game.getInstance().getSceneManager().setScene(new LevelEditorSelectionScene()));
addMenuEntry("Exit Game", e -> System.exit(0));
build();
}
}
| true
|
f87531e256a251c869f8dea92cd2469f9b2589de
|
Java
|
hamidds/SBU_AP_MiniProject
|
/src/Controller/professorsPanelController.java
|
UTF-8
| 1,229
| 2.3125
| 2
|
[] |
no_license
|
package Controller;
import Model.PageLoader;
import Model.users.Professor;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.Label;
import java.io.IOException;
import java.net.URL;
import java.util.ResourceBundle;
public class professorsPanelController implements Initializable {
@FXML
public Label nameLabel;
@FXML
public Label creditLabel;
@FXML
public Label markLabel;
Professor obj = (Professor) LogedInUser.getLoggedInUser();
public void settingEnter(ActionEvent actionEvent) throws IOException {
new PageLoader().Load("../View/Setting.fxml");
}
public void logout(ActionEvent actionEvent) throws IOException {
new PageLoader().Load("../View/Log-in.fxml");
}
public void ClassSettingsEnter(ActionEvent actionEvent) throws IOException {
new PageLoader().Load("../View/ClassSettings.fxml");
}
public void Grades(ActionEvent actionEvent) throws IOException {
new PageLoader().Load("../View/GradesList.fxml");
}
@Override
public void initialize(URL location, ResourceBundle resources) {
nameLabel.setText("Name : " + obj.toString());
}
}
| true
|
f8e56c1c3ef59cbaf76e6c3578ca825bf121b9e1
|
Java
|
prudnicki/loans
|
/src/test/java/com/prudnicki/loans/loan/controller/ExtensionControllerTest.java
|
UTF-8
| 6,511
| 1.984375
| 2
|
[] |
no_license
|
package com.prudnicki.loans.loan.controller;
import com.prudnicki.loans.loan.model.Extension;
import com.prudnicki.loans.loan.model.Loan;
import com.prudnicki.loans.loan.repository.ExtensionRepository;
import com.prudnicki.loans.loan.repository.LoanRepository;
import com.prudnicki.loans.loan.service.ExtensionService;
import com.prudnicki.loans.loan.TestDataUtil;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.core.Is.is;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
public class ExtensionControllerTest {
private static final Long LOAN_ID = 10L;
private static final Long EXTENSION_ID = 10L;
private static final String ALL_LOANS_EXTENSIONS_URL = "/loans/" + LOAN_ID + "/extensions/";
private static final String SINGLE_EXTENSION_URL = ALL_LOANS_EXTENSIONS_URL + EXTENSION_ID;
@Mock
private ExtensionRepository extensionRepository;
@Mock
private LoanRepository loanRepository;
@Mock
private ExtensionService service;
@InjectMocks
private ExtensionController controller;
private MockMvc mockMvc;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
mockMvc = MockMvcBuilders
.standaloneSetup(controller)
.setMessageConverters(ControllerTestUtil.getConfiguredConverter())
.build();
}
@Test
public void shouldReturnNotFoundForInvaliExtensionId() throws Exception {
//given
when(extensionRepository.findOne(EXTENSION_ID)).thenReturn(null);
//when
ResultActions response = mockMvc.perform(get(SINGLE_EXTENSION_URL));
//then
response.andExpect(status().isNotFound());
}
@Test
public void shouldReturnNotFoundForInvalidLoanId() throws Exception {
//given
Loan loan = TestDataUtil.createLoanWithExtensions();
Long invalidLoanId = 12L;
loan.setId(invalidLoanId);
when(extensionRepository.findOne(EXTENSION_ID)).thenReturn(loan.getExtensions().get(0));
//when
//URL contains valid LOAN_ID != invaliLoanId
ResultActions response = mockMvc.perform(get(SINGLE_EXTENSION_URL));
//then
response.andExpect(status().isNotFound());
}
@Test
public void shouldFindExtensionById() throws Exception {
//given
Loan loan = TestDataUtil.createLoanWithExtensions();
Extension extension = loan.getExtensions().get(0);
when(extensionRepository.findOne(EXTENSION_ID)).thenReturn(extension);
//when
ResultActions response = mockMvc.perform(get(SINGLE_EXTENSION_URL));
//then
verifyExtensionAgainstResponse(extension, response);
}
private void verifyExtensionAgainstResponse(Extension extension, ResultActions response) throws Exception {
verifyExtensionAgainstResponse(extension, response, "$.");
}
private void verifyExtensionAgainstResponse(Extension extension, ResultActions response,
String fieldSelectorPrefix) throws Exception {
response.andExpect(status().isOk())
.andExpect(jsonPath(fieldSelectorPrefix + "interestBefore",
is(extension.getInterestBefore().doubleValue())))
.andExpect(jsonPath(fieldSelectorPrefix + "interestAfter",
is(extension.getInterestAfter().doubleValue())))
.andExpect(jsonPath(fieldSelectorPrefix + "termBefore",
is(ControllerTestUtil.convertLocalDateTime(extension.getTermBefore()))))
.andExpect(jsonPath(fieldSelectorPrefix + "termAfter",
is(ControllerTestUtil.convertLocalDateTime(extension.getTermAfter()))));
if (extension.getId() != null) {
response.andExpect(jsonPath(fieldSelectorPrefix + "id", is(extension.getId().intValue())));
}
}
@Test
public void shouldListLoansExtensions() throws Exception {
//given
Loan loan = TestDataUtil.createLoanWithExtensions();
when(extensionRepository.findAllByLoan_Id(LOAN_ID)).thenReturn(loan.getExtensions());
//when
ResultActions response = mockMvc.perform(get(ALL_LOANS_EXTENSIONS_URL));
//then
verifyExtensionAgainstResponseWithArrayIndex(loan.getExtensions().get(0), response, 0);
verifyExtensionAgainstResponseWithArrayIndex(loan.getExtensions().get(1), response, 1);
}
private void verifyExtensionAgainstResponseWithArrayIndex(Extension extension, ResultActions response,
Integer index) throws Exception {
verifyExtensionAgainstResponse(extension, response, "$[" + index + "].");
}
@Test
public void shouldReturnNotFoundOnExtensionOfMissingLoan() throws Exception {
//given
when(loanRepository.findOne(LOAN_ID)).thenReturn(null);
//when
ResultActions response = mockMvc.perform(post(ALL_LOANS_EXTENSIONS_URL));
//then
response.andExpect(status().isNotFound());
}
@Test
public void shouldExtendLoan() throws Exception {
//given
Loan loan = TestDataUtil.createLoan();
Extension extension = TestDataUtil.createExtension();
extension.setId(EXTENSION_ID);
when(loanRepository.findOne(LOAN_ID)).thenReturn(loan);
when(service.extendLoan(loan)).thenReturn(extension);
//when
ResultActions response = mockMvc.perform(post(ALL_LOANS_EXTENSIONS_URL));
//then
response.andExpect(status().isCreated())
.andExpect(header().string("Location", endsWith(SINGLE_EXTENSION_URL)));
}
}
| true
|
65061c314551e8a49a57627dd82dfc235d4f04a1
|
Java
|
pandurangkapate/Test
|
/Assignment_1/src/Volumeofsphere.java
|
UTF-8
| 233
| 3.125
| 3
|
[] |
no_license
|
public class Volumeofsphere {
public static void volume ( double radius) {
double VolumeofSphere = 4/3 * Math.PI * (radius * radius * radius);
System.out.format("\n The volume of Sphere= %2f", VolumeofSphere);
}
}
| true
|
9c951736be9fb0cc17b86e60dff29c0c9c227d23
|
Java
|
TMargaret/Diplomatiki2
|
/Diplomatiki-SavingData/Greenfoot-Thesis-mainRoomAttempt/tuto/DLevel_2.java
|
UTF-8
| 951
| 2.296875
| 2
|
[] |
no_license
|
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
/**
* Write a description of class Level2 here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class DLevel_2 extends DragonLevel
{
Alex alex;
d2 dragon2;
/**
* Constructor for objects of class Level2.
*
*/
public DLevel_2()
{
//prepare();
dragon2 = new d2();
addObject(dragon2,865,153);
}
public DLevel_2(Alex oldAlex)
{
super(oldAlex);
alex = oldAlex;
//prepare();
dragon2 = new d2();
addObject(dragon2,865,153);
//suspenseSound.playLoop();
}
public void act(){
endGame();
}
public void endGame(){
if (dragon2.endLevel()){
LevelsScreen.writefile(3);
Greenfoot.setWorld(new LevelsScreen());
suspenseSound.stop();
}
}
}
| true
|
07bb1a1cc27a01c38631c70a82276b8c1d42ef99
|
Java
|
jamesan/datacrow
|
/_source/net/datacrow/core/objects/helpers/AudioCD.java
|
UTF-8
| 2,595
| 1.65625
| 2
|
[] |
no_license
|
/******************************************************************************
* __ *
* <-----/@@\-----> *
* <-< < \\// > >-> *
* <-<-\ __ /->-> *
* Data / \ Crow *
* ^ ^ *
* info@datacrow.net *
* *
* This file is part of Data Crow. *
* Data Crow 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 any later version. *
* *
* Data Crow is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
* See the GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public *
* License along with this program. If not, see http://www.gnu.org/licenses *
* *
******************************************************************************/
package net.datacrow.core.objects.helpers;
import net.datacrow.core.modules.DcModules;
import net.datacrow.core.objects.DcMediaObject;
public class AudioCD extends DcMediaObject {
private static final long serialVersionUID = -9181349541953148790L;
public static final int _F_ARTISTS = 1;
public static final int _G_GENRES = 2;
public static final int _H_PICTUREFRONT = 3;
public static final int _I_PICTUREBACK = 4;
public static final int _J_PICTURECD = 5;
public static final int _L_STATE = 7;
public static final int _M_WEBPAGE = 8;
public static final int _N_EAN = 9;
public AudioCD() {
super(DcModules._AUDIOCD);
}
}
| true
|
0f67e09db6ba15c7f47d422cf30c55cb720bb582
|
Java
|
WeControlTheFuture/fdesigner-ui
|
/jface/org/fdesigner/ui/jface/databinding/viewers/ViewerValueProperty.java
|
UTF-8
| 2,632
| 2.015625
| 2
|
[] |
no_license
|
/*******************************************************************************
* Copyright (c) 2008, 2015 Matthew Hall and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* Matthew Hall - initial API and implementation (bug 194734)
* Matthew Hall - bugs 263413, 264286
******************************************************************************/
package org.fdesigner.ui.jface.databinding.viewers;
import org.fdesigner.databinding.observable.Realm;
import org.fdesigner.databinding.observable.value.IObservableValue;
import org.fdesigner.databinding.property.value.SimpleValueProperty;
import org.fdesigner.ui.jface.databinding.internal.databinding.viewers.ViewerObservableValueDecorator;
import org.fdesigner.ui.jface.databinding.swt.DisplayRealm;
import org.fdesigner.ui.jface.viewers.Viewer;
/**
* Abstract value property implementation for {@link Viewer} properties. This
* class implements some basic behavior that viewer properties are generally
* expected to have, namely:
* <ul>
* <li>Calling {@link #observe(Object)} should create the observable on the
* display realm of the viewer's control, rather than the current default realm
* <li>All <code>observe()</code> methods should return an
* {@link IViewerObservableValue}
* </ul>
*
* @param <S> type of the source object
* @param <T> type of the value of the property
*
* @since 1.3
*/
public abstract class ViewerValueProperty<S, T> extends SimpleValueProperty<S, T>
implements IViewerValueProperty<S, T> {
@Override
public IObservableValue<T> observe(S source) {
if (source instanceof Viewer) {
return observe((Viewer) source);
}
return super.observe(source);
}
@Override
public IObservableValue<T> observe(Realm realm, S source) {
IObservableValue<T> observable = super.observe(realm, source);
if (source instanceof Viewer)
observable = new ViewerObservableValueDecorator<>(observable, (Viewer) source);
return observable;
}
@SuppressWarnings("unchecked")
@Override
public IViewerObservableValue<T> observe(Viewer viewer) {
return (IViewerObservableValue<T>) observe(DisplayRealm.getRealm(viewer.getControl().getDisplay()), (S) viewer);
}
@Override
public IViewerObservableValue<T> observeDelayed(int delay, Viewer viewer) {
return ViewersObservables.observeDelayedValue(delay, observe(viewer));
}
}
| true
|
eb3aaa9082767a2f3d3d5f35b946bd9fb3a639d7
|
Java
|
RobbieLan/workspace
|
/drools/CustomerSecurityManagementSystem-master/CustomerSecurityManagementWeb/src/main/java/com/elulian/CustomerSecurityManagementSystem/web/customerInfo/CustomerInfoAction.java
|
UTF-8
| 9,343
| 1.921875
| 2
|
[] |
no_license
|
package com.elulian.CustomerSecurityManagementSystem.web.customerInfo;
import java.util.List;
import java.util.Map;
import javax.persistence.Query;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.struts2.interceptor.ParameterAware;
import org.apache.struts2.interceptor.SessionAware;
import org.apache.struts2.json.annotations.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.stereotype.Controller;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionSupport;
import com.elulian.CustomerSecurityManagementSystem.common.Config;
import com.elulian.CustomerSecurityManagementSystem.exception.DataMissingException;
import com.elulian.CustomerSecurityManagementSystem.exception.ExistsException;
import com.elulian.CustomerSecurityManagementSystem.service.ICustomerInfoService;
import com.elulian.CustomerSecurityManagementSystem.service.IThresholdService;
import com.elulian.CustomerSecurityManagementSystem.service.ServiceFactory;
import com.elulian.CustomerSecurityManagementSystem.service.impl.CustomerInfoService;
import com.elulian.CustomerSecurityManagementSystem.vo.Condition;
import com.elulian.CustomerSecurityManagementSystem.vo.CustomerInfo;
@Controller("customerInfoAction") @Scope("prototype")
public class CustomerInfoAction extends ActionSupport implements
ParameterAware, SessionAware {
private static Logger logger = LoggerFactory.getLogger(CustomerInfoAction.class);
@Autowired
private ICustomerInfoService customerInfoService;
private List<CustomerInfo> customerInfos;
private CustomerInfo customerInfo;
private Integer id;
private Condition condition;
private Map<String, String[]> params;
private Map<String, Object> sessionMap;
@Deprecated
private boolean hasNext = false;
@Deprecated
private boolean hasPrevious = false;
@Deprecated
private int currentPage = 1;
@Deprecated
private long totalPage;
@Deprecated
private int pageSize = Config.getInstance().getPageSizeByKey("pageSize");
private long totalCount = 0;
/*
* JSON return value for EXT form submission (save/delete action). EXT
* require response: would process the following server response for a
* successful submission: { success: true, msg: 'Consignment updated' } and
* the following server response for a failed submission: { success: false,
* msg: 'You do not have permission to perform this operation' }
*/
private boolean actionResult;
private String actionMessage;
public CustomerInfoAction() {
/*if (customerInfoService == null)
customerInfoService = new CustomerInfoService();*/
}
@JSON(name = "success")
public boolean getActionResult() {
return actionResult;
}
@JSON(name = "msg")
public String getActionMessage() {
return actionMessage;
}
@JSON(name = "customerInfos")
public List<CustomerInfo> getCustomerInfos() {
return customerInfos;
}
@JSON(name = "totalCount")
public long getTotalCount() {
return totalCount;
}
public CustomerInfo getCustomerInfo() {
return customerInfo;
}
public void setCustomerInfo(CustomerInfo customerInfo) {
this.customerInfo = customerInfo;
}
public Condition getCondition() {
return condition;
}
@Deprecated
public boolean isHasNext() {
return hasNext;
}
@Deprecated
public boolean isHasPrevious() {
return hasPrevious;
}
@Deprecated
public long getTotalPage() {
return totalPage;
}
@Deprecated
public int getCurrentPage() {
return currentPage;
}
public void setCondition(Condition condition) {
this.condition = condition;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Deprecated
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
@Deprecated
public String list() {
setInfos();
return Action.SUCCESS;
}
@Deprecated
/**
* remain for condition constructor, should be removed later, construct condition in the client side instead of server side
*/
private void setInfos() {
if (condition == null) {
// access without condtion
logger
.debug("First time to access customerInfoAction, create a condition object");
condition = new Condition();
} else {
if (condition.getCustomerId() != null
&& condition.getCustomerId().length() == 0)
condition.setCustomerId(null);
if (condition.getSearchBranch() != null
&& condition.getSearchBranch().length() == 0)
condition.setSearchBranch(null);
}
// get user branch
String branch = (String) sessionMap.get("branch");
// set user branch if user branch is not ALL
// normal user can only see the customerInfos in his/her branch
logger.debug(branch + "***********************");
if (branch != null && (!branch.equalsIgnoreCase("ALL"))) {
condition.setSearchBranch(branch);
}
long total = customerInfoService.getTotalCount(condition);
totalPage = (total % pageSize == 0) ? (total / pageSize) : (total
/ pageSize + 1);
if (totalPage == 0)
totalPage = 1;
// set currentPage if pageNum is exist.
if (params.get("pageNum") != null) {
int pageNum = Integer.valueOf((params.get("pageNum"))[0]);
logger.debug(logger.getName() + pageNum);
if (pageNum >= 1 && pageNum <= totalPage) {
currentPage = pageNum;
}
}
condition.setStartRow((currentPage - 1) * pageSize);
condition.setMaxRow(pageSize);
hasNext = (currentPage < totalPage) ? true : false;
hasPrevious = (currentPage <= 1) ? false : true;
this.customerInfos = customerInfoService.getCustomerInfosByCondition(condition);
}
/**
* Replaced by extPaging
*/
@Deprecated
public String search() {
setInfos();
return Action.SUCCESS;
}
public void prepare() throws Exception {
if (id != null)
customerInfo = customerInfoService.findById(id);
}
public String detailInfo() {
if (customerInfo == null && id != null)
customerInfo = customerInfoService.findById(id);
return SUCCESS;
}
/**
* Update CustomerInfo
*
* @return
*/
public String save() {
if(logger.isDebugEnabled()){
logger.debug("******************** save");
try{
logger.debug(params.get("customerInfo.sex")[0]);
logger.debug(new String(params.get("customerInfo.sex")[0].getBytes("UTF-8")));
} catch (Exception e){
}
}
if (customerInfo != null) {
try {
customerInfoService.save(customerInfo);
} catch (DataIntegrityViolationException e) {
logger.error(e.getMessage(), e);
} catch (InvalidDataAccessApiUsageException e) {
logger.error(e.getMessage(), e);
}
actionResult = true;
actionMessage = "CustomerInfo Update successful!";
customerInfo = new CustomerInfo();
return SUCCESS;
}
actionResult = false;
actionMessage = "CustomerInfo is null!";
return ERROR;
}
/**
* delete customerInfo by ID
*
* @return
*/
public String delete() {
if (id != null) {
customerInfoService.remove(id);
id = null;
actionResult = true;
actionMessage = "CustomerInfo delete successful!";
return SUCCESS;
}
actionResult = false;
actionMessage = "CustomerInfo is null!";
return ERROR;
}
public String processCustomerRiskInfo() {
Condition con = new Condition();
long startTime = System.currentTimeMillis();
long count = customerInfoService.getTotalCount();
List<CustomerInfo> list = null;
String temp = null;
// should replace with a list of thresholds with execute method
for (int i = 0; i <= count; i = i + 100) {
con.setStartRow(i);
con.setMaxRow(100);
list = customerInfoService.getCustomerInfosByCondition(con);
for (CustomerInfo info : list) {
customerInfoService.setMatchThresholdsInfo(info);
customerInfoService.save(info);
}
}
long endTime = System.currentTimeMillis();
logger.info("Disposal time: " + (endTime - startTime));
return SUCCESS;
}
public String extPaging() {
if (condition == null) {
condition = new Condition();
} else {
if (condition.getCustomerId() != null
&& condition.getCustomerId().length() == 0)
condition.setCustomerId(null);
if (condition.getSearchBranch() != null
&& condition.getSearchBranch().length() == 0)
condition.setSearchBranch(null);
}
int start = 0;
int limit = pageSize;
if (params.get("start") != null && params.get("start").length > 0) {
start = Integer.valueOf((params.get("start"))[0]);
}
if (params.get("limit") != null && params.get("limit").length > 0) {
limit = Integer.valueOf((params.get("limit"))[0]);
}
if (params.get("sort") != null && params.get("sort").length > 0) {
condition.setSortBy((params.get("sort"))[0]);
}
if (params.get("dir") != null && params.get("dir").length > 0) {
condition.setSortType((params.get("dir"))[0]);
}
condition.setStartRow(start);
condition.setMaxRow(limit);
this.totalCount = customerInfoService.getTotalCount(condition);
this.customerInfos = customerInfoService.getCustomerInfosByCondition(condition);
return SUCCESS;
}
@Override
public void setParameters(Map<String, String[]> params) {
this.params = params;
}
@Override
public void setSession(Map<String, Object> sessionMap) {
this.sessionMap = sessionMap;
}
}
| true
|
c0ae1f11eeb7f1fecfbe066cebd33a402b3810e3
|
Java
|
Duckdan/DefineDividerItemView
|
/app/src/main/java/study/yang/definedivideritemview/MainActivity.java
|
UTF-8
| 1,311
| 2.0625
| 2
|
[
"Apache-2.0"
] |
permissive
|
package study.yang.definedivideritemview;
import android.content.Context;
import android.graphics.Color;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
public class MainActivity extends AppCompatActivity {
private RecyclerView rv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
rv = (RecyclerView) findViewById(R.id.rv);
rv.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
DefineDividerItem dividerItem = new DefineDividerItem();
dividerItem.setDrawable(getResources().getDrawable(R.drawable.item_vertical_divider));
dividerItem.setOrientation(DefineDividerItem.VERTICAL);
rv.addItemDecoration(dividerItem);
RvVerticalAdapter verticalAdapter = new RvVerticalAdapter(this);
RvHorizontalAdapter horizontalAdapter = new RvHorizontalAdapter(this);
rv.setAdapter(verticalAdapter);
}
}
| true
|
d3b2057b4d61c998652aa9b633269dc82e52641a
|
Java
|
amritashrivastava1205/amrita-complex-test-cases
|
/final-framework-testng/src/com/training/pom/MultipleusersenquiryPOM064.java
|
UTF-8
| 2,156
| 1.960938
| 2
|
[] |
no_license
|
package com.training.pom;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Action;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
//import oracle.jdbc.pool.OracleDataSource;
public class MultipleusersenquiryPOM064 {
private WebDriver driver;
public MultipleusersenquiryPOM064(WebDriver driver) {
this.driver = driver;
PageFactory.initElements(driver, this);
}
@FindBy(xpath="//*[@id=\"menu-item-346\"]/a")
private WebElement apartments;
@FindBy(xpath="//*[@id=\"wpmm-megamenu\"]/div[2]/div[2]")
private WebElement gateway55;
@FindBy(xpath="//*[@id=\"wpcf7-f4-o1\"]/form/p[1]/label/span/input")
private WebElement name;
@FindBy(xpath="//*[@id=\"wpcf7-f4-o1\"]/form/p[2]/label/span/input")
private WebElement email;
@FindBy(xpath="//*[@id=\"wpcf7-f4-o1\"]/form/p[4]/label/span/textarea")
private WebElement subject;
@FindBy(xpath="//*[@id=\"wpcf7-f4-o1\"]/form/p[4]/label/span/textarea")
private WebElement yourmessage;
@FindBy(xpath="//*[@id=\"wpcf7-f4-o1\"]/form/p[5]/input")
private WebElement sendbttn;
public void mouseoverapartments() {
Actions action=new Actions(driver);
action.moveToElement(this.apartments).build().perform();
}
public void mouseovergateway55() {
Actions action=new Actions(driver);
action.moveToElement(this.gateway55).build().perform();
}
public void clickgateway55() {
// TODO Auto-generated method stub
this.gateway55.click();
}
public void sendname(String name) {
this.name.click();
this.name.sendKeys(name);
}
public void sendemail(String email) {
this.email.click();
this.email.sendKeys(email);
}
public void sendsubject(String subject) {
this.subject.click();
this.subject.sendKeys(subject);
}
public void sendyourmessage(String yourmessage) {
this.yourmessage.click();
this.yourmessage.sendKeys(yourmessage);
}
public void clicksendbttn() {
this.sendbttn.click();
}
}
| true
|
ac84238a87c84024a0bd25615133b8b346a7d85e
|
Java
|
wudi1986/MyApplication
|
/ClockCalendar/src/com/yktx/check/SetTaskSortActivity.java
|
UTF-8
| 3,790
| 2.09375
| 2
|
[] |
no_license
|
package com.yktx.check;
import java.util.ArrayList;
import android.content.Context;
import android.content.Intent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;
import com.umeng.analytics.MobclickAgent;
import com.yktx.check.bean.ByDateBean;
import com.yktx.check.listview.DragView;
import com.yktx.check.util.Tools;
public class SetTaskSortActivity extends BaseActivity{
private DragListAdapter adapter = null;
static ArrayList<ByDateBean> list;
@Override
protected void findViews() {
// TODO Auto-generated method stub
setContentView(R.layout.activity_task_sort);
}
@Override
protected void init() {
// TODO Auto-generated method stub
initTitle();
list = (ArrayList<ByDateBean>) getIntent().getSerializableExtra("LIST");
DragView dragView = (DragView) this.findViewById(R.id.dragView);
adapter = new DragListAdapter(this, list);
dragView.setAdapter(adapter);
}
@Override
protected void setListeners() {
// TODO Auto-generated method stub
}
private void initTitle(){
ImageView title_item_leftImage = (ImageView)findViewById(R.id.title_item_leftImage);
TextView title_item_content = (TextView)findViewById(R.id.title_item_content);
ImageView title_item_rightImage = (ImageView)findViewById(R.id.title_item_rightImage);
TextView title_item_rightText = (TextView)findViewById(R.id.title_item_rightText);
TextView title_item_leftText = (TextView)findViewById(R.id.title_item_leftText);
title_item_leftImage.setVisibility(View.VISIBLE);
title_item_rightImage.setVisibility(View.GONE);
title_item_rightText.setVisibility(View.VISIBLE);
title_item_leftText.setVisibility(View.GONE);
title_item_content.setVisibility(View.GONE);
title_item_rightText.setText("完成");
title_item_leftImage.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
SetTaskSortActivity.this.finish();
}
});
title_item_rightText.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
Intent intent=new Intent();
intent.putExtra("LIST", (java.io.Serializable) list);
setResult(RESULT_OK, intent);
SetTaskSortActivity.this.finish();
}
});
}
//渲染不同的view
public class DragListAdapter extends ArrayAdapter<ByDateBean>{
public DragListAdapter(Context context,ArrayList<ByDateBean> objects) {
super(context, 0, objects);
}
public ArrayList<ByDateBean> getList(){
return list;
}
//利用模板布局不同的listview
@Override
public View getView(int position, View convertView, ViewGroup parent) {
View view = convertView;
view = LayoutInflater.from(getContext()).inflate(R.layout.textandimage, null);
TextView textView = (TextView) view.findViewById(R.id.headtext);
textView.setText(list.get(position).getTitle());
Tools.getLog(Tools.i, "aaa", "list.get(position).getTitle() =========== "+list.get(position).getTitle());
return view;
}
}
public void onResume() {
super.onResume();
MobclickAgent.onPageStart("SplashScreen"); //统计页面(仅有Activity的应用中SDK自动调用，不需要单独写)
MobclickAgent.onResume(this); //统计时长
}
public void onPause() {
super.onPause();
MobclickAgent.onPageEnd("SplashScreen"); // （仅有Activity的应用中SDK自动调用，不需要单独写）保证 onPageEnd 在onPause 之前调用,因为 onPause 中会保存信息
MobclickAgent.onPause(this);
}
}
| true
|
6e80fc9c6f00e85badaf686a286dbc7af817fc73
|
Java
|
xtiko14/AndroidTVOnline
|
/app/src/main/java/com/xinshiyun/smarttvonline/activity/adapter/MyRecyclerAdapter.java
|
UTF-8
| 1,576
| 2.25
| 2
|
[] |
no_license
|
package com.xinshiyun.smarttvonline.activity.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.RelativeLayout;
import android.widget.TextView;
import com.xinshiyun.smarttvonline.R;
/**
* @date 2017/4/11 15:35
*/
public class MyRecyclerAdapter extends RecyclerView.Adapter<MyRecyclerAdapter.ViewHolder> {
private Context context;
public MyRecyclerAdapter(Context context) {
this.context = context;
}
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_my_recycler, parent, false);
return new ViewHolder(v);
}
@Override
public void onBindViewHolder(final ViewHolder holder, final int position) {
holder.itemTV.setText("item" + position);
holder.itemRL.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
}
@Override
public int getItemCount() {
return 100;
}
public static class ViewHolder extends RecyclerView.ViewHolder {
public TextView itemTV;
public RelativeLayout itemRL;
public ViewHolder(View itemView) {
super(itemView);
itemTV = (TextView) itemView.findViewById(R.id.itemTV);
itemRL = (RelativeLayout) itemView.findViewById(R.id.itemRL);
}
}
}
| true
|
82340a7778b0d4251d5851f22c8cfb6bf372c104
|
Java
|
GHJaewoonLee/MapAPITest
|
/Daum/src/control/SearchTourControl.java
|
UTF-8
| 1,322
| 2.28125
| 2
|
[] |
no_license
|
package control;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import service.SearchTourService;
@WebServlet("/searchtour")
public class SearchTourControl extends HttpServlet {
private static final long serialVersionUID = 1L;
SearchTourService searchTourService;
public SearchTourControl() {
searchTourService = new SearchTourService();
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String location = request.getParameter("location");
String place = request.getParameter("place");
String result = searchTourService.getKeywordSearch(location, place);
request.setAttribute("result", result);
String path = "/searchTourResult.jsp";
RequestDispatcher dispatcher = request.getRequestDispatcher(path);
dispatcher.forward(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
doGet(request, response);
}
}
| true
|
d5e3e14fdfee82814f5070c7f7bf2b77badb5421
|
Java
|
harry0714/ieat
|
/iEat/src/com/article/model/ArticleAppDAO.java
|
UTF-8
| 5,427
| 2.125
| 2
|
[] |
no_license
|
package com.article.model;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import javax.xml.bind.DatatypeConverter;
//import com.article_report.model.Article_ReportVO;
//import com.article_response.model.Article_ResponseVO;
//import jbdcUtil.CompositeQuery_Article_rs;
public class ArticleAppDAO implements ArticleAppDAO_interface {
private String result;
private byte[] imagebytes;
private static DataSource ds = null;
static {
try {
Context ctx = new InitialContext();
ds = (DataSource) ctx.lookup("java:comp/env/jdbc/iEatDB");
} catch (NamingException e) {
e.printStackTrace();
}
}
private static final String GET_IMAGE_BY_ART_NO_STMT = "SELECT ART_CONTEXT FROM ARTICLE WHERE ART_NO=?";
private static final String GET_ALLWITHNAME = "SELECT art_no,art_name, art_date,art_context,article.mem_no, mem_name FROM ARTICLE left join member on article.mem_no = member.mem_no order by art_no desc";
@Override
public Map<String,ArticleVO> getAllWithName() {
Map<String,ArticleVO> list = new LinkedHashMap<String,ArticleVO>();
ArticleVO articleVO = null;
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
StringBuilder sb = null;
StringBuilder result = null;
String finalString = "";
try {
con = ds.getConnection();
pstmt = con.prepareStatement(GET_ALLWITHNAME);
rs = pstmt.executeQuery();
while (rs.next()) {
String art_mem_no = (rs.getString("art_no")+","+rs.getString("mem_name"));
articleVO = new ArticleVO();
articleVO.setArt_no(rs.getString("art_no"));
articleVO.setArt_date(rs.getTimestamp("art_date"));
articleVO.setArt_name(rs.getString("art_name"));
articleVO.setMem_no(rs.getString("mem_no"));
sb =new StringBuilder(rs.getString("art_context"));
result = new StringBuilder();
int count = 50;
while(sb.indexOf("<p>")!=-1&&result.length()<count){
if(sb.substring(sb.indexOf("<p>"), sb.indexOf("</p>")+4).indexOf("<img")>=0){
sb.delete(sb.indexOf("<p>"), sb.indexOf("</p>")+4);
}else{
int index = sb.substring(sb.indexOf("<p>"), sb.indexOf("</p>")).indexOf("<br />");
while(index!=-1){
sb.replace(sb.indexOf("<br />"), sb.indexOf("<br />") + 6, " ");
index = sb.substring(sb.indexOf("<p>"), sb.indexOf("</p>")).indexOf("<br />");
}
result.append(sb.substring(sb.indexOf("<p>")+3, sb.indexOf("</p>")));
sb.delete(sb.indexOf("<p>"), sb.indexOf("</p>")+4);
}
}
if(result.length()>=count){
finalString = result.substring(0,count).toString()+"...";
}else{
finalString = result.toString()+"...";
}
articleVO.setArt_context(finalString);
list.put(art_mem_no,articleVO); // Store the row in the list
}
// Handle any driver errors
} catch (SQLException se) {
throw new RuntimeException("A database error occured. " + se.getMessage());
// Clean up JDBC resources
} finally {
if (rs != null) {
try {
rs.close();
} catch (SQLException se) {
se.printStackTrace(System.err);
}
}
if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException se) {
se.printStackTrace(System.err);
}
}
if (con != null) {
try {
con.close();
} catch (Exception e) {
e.printStackTrace(System.err);
}
}
}
return list;
}
@Override
public byte[] getImage(String art_no) {
// TODO Auto-generated method stub
Connection con = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String img = null;
try {
con = ds.getConnection();
pstmt = con.prepareStatement(GET_IMAGE_BY_ART_NO_STMT);
pstmt.setString(1, art_no);
rs = pstmt.executeQuery();
while (rs.next()) {
img = rs.getString(1);
}
if (img.contains("<img")) {
result = img.substring(img.indexOf("src=\"data:image/jpeg;base64,") + 28);
if(result.contains("\"")){
result =result.substring(0, result.indexOf("\""));
}
System.out.println("clob圖片的String字串" + result);
// final Base64.Decoder decoder = Base64.getDecoder();
imagebytes = DatatypeConverter.parseBase64Binary(result);
}
System.out.println("imagebytes =" + imagebytes);
} catch (SQLException se) {
throw new RuntimeException("A database error occured. " + se.getMessage());
// Clean up JDBC resources
} finally {
if (rs != null) {
try {
rs.close();
} catch (SQLException se) {
se.printStackTrace(System.err);
}
}
if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException se) {
se.printStackTrace(System.err);
}
}
if (con != null) {
try {
con.close();
} catch (Exception e) {
e.printStackTrace(System.err);
}
}
}
return imagebytes;
}
}
| true
|
399dd2a57b5fae17986f1199687c2b0e440f7323
|
Java
|
sisyphus1998/LL1Parser
|
/LLOneParser.java
|
UTF-8
| 3,849
| 3.03125
| 3
|
[] |
no_license
|
package compilerDesign;
import java.util.*;
public class LLOneParser {
private List<Production> productions;
private List<Variable> variables;
private List<ParsingTableObjects> ptobjects;
private Stack<Variable> varStack;
public LLOneParser(LRFreeGrammar lrobj) {
productions=new ArrayList<Production>();
variables=new ArrayList<Variable>();
ptobjects=new ArrayList<ParsingTableObjects>();
varStack=new Stack<Variable>();
productions.addAll(lrobj.getProds());
variables.addAll(lrobj.getVars());
this.makeParsingTable();
varStack.push(new Variable("$"));
varStack.push(variables.get(0));
}
private void makeParsingTable() {
//System.out.println(variables.get(0).getName()+"\r\n");
for(Production p:productions) {
//System.out.println(p.getLeft().getName()+"->"+p);
Set<Variable> terms=new HashSet<Variable>();
terms.addAll(this.findTerminals(p.getLeft(), p.getRight()));
for(Variable v:terms) {
int index=variables.indexOf(p.getLeft());
ParsingTableObjects temp=new ParsingTableObjects(variables.get(index),v,p);
if(!ptobjects.contains(temp)) ptobjects.add(temp);
else {
System.out.println("Error while creating parsing table\r\nProduction conflict at T["+p.getLeft().getName()+","+v.getName()+"]");
System.out.println("Previous production retained");
}
}
}
}
public void printParsingTable() {
System.out.println("\r\n----PARSING TABLE----\r\n");
for(ParsingTableObjects pto:ptobjects) {
System.out.println(pto);
}
}
public boolean checkString(String src) {
int index=0;
int count=0;
String[] arrayStr=src.split(":");
while(true) {
count++;
System.out.print("Step "+count+":");
for(int i=0;i<varStack.size();i++) {
System.out.print(varStack.get(i).getName()+" ");
}
System.out.println();
if(varStack.isEmpty()) {
varStack.push(new Variable("$"));
varStack.push(variables.get(0));
return true;
}
Variable vt=varStack.peek();
Variable tt=new Variable(arrayStr[index]);
if(vt.equals(tt)) {
varStack.pop();
index++;
continue;
}
List<Variable> templist=new ArrayList<Variable>();
templist.addAll(this.varSequence(vt, tt));
if(templist.isEmpty()) {
varStack.clear();
varStack.push(new Variable("$"));
varStack.push(variables.get(0));
return false;
}
templist.remove(new Variable("eps"));
varStack.pop();
for(int i=0;i<templist.size();i++) {
varStack.push(templist.get(i));
}
}
}
private List<Variable> varSequence(Variable nt,Variable te){
ParsingTableObjects newpto=new ParsingTableObjects(nt,te);
int index=ptobjects.indexOf(newpto);
List<Variable> newlist=new ArrayList<Variable>();
if(index==-1) return newlist;
newlist.addAll(ptobjects.get(index).getP().getRight());
for(int i=0;i<(int)newlist.size()/2;i++) {
Variable temp=newlist.get(i);
newlist.remove(i);
newlist.add(i, newlist.get(newlist.size()-1-i));
newlist.remove(newlist.size()-1-i);
newlist.add(newlist.size()-i, temp);
}
//newlist.remove(new Variable("eps"));
return newlist;
}
private Set<Variable> findTerminals(Variable lhs,List<Variable> rhs) {
Set<Variable> tempset=new HashSet<Variable>();
int i;
for(i=0;i<rhs.size();i++) {
int x=variables.indexOf(rhs.get(i));
if(rhs.get(i).equals(new Variable("eps"))) continue;
if(x==-1) {
tempset.add(rhs.get(i));
break;
}
tempset.addAll(variables.get(x).getFirst());
if(!tempset.contains(new Variable("eps"))) {
break;
}
tempset.remove(new Variable("eps"));
}
if(i==rhs.size()) {
int in=variables.indexOf(lhs);
if(in!=-1)
tempset.addAll(variables.get(in).getFollow());
}
return tempset;
}
}
| true
|
cfb13530495bdd89114f6692b7344220f3fe054b
|
Java
|
agaszab/library
|
/src/main/java/pl/vxm/netino/books/mod/Book.java
|
UTF-8
| 1,988
| 2.484375
| 2
|
[] |
no_license
|
package pl.vxm.netino.books.mod;
import javax.persistence.*;
@Entity
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long idb;
private String title;
private String author;
@ManyToOne
private Category category;
private String publisher;
@Column(columnDefinition = "TEXT")
private String description;
private int publicationYear;
public Book() {
}
public Book(String title, String author, Category category, String publisher, String description, int publicationYear) {
this.title = title;
this.author = author;
this.category = category;
this.publisher = publisher;
this.description = description;
this.publicationYear = publicationYear;
}
public Long getIdb() {
return idb;
}
public void setIdb(Long idb) {
this.idb = idb;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public Category getCategory() {
return category;
}
public void setCategory(Category category) {
this.category = category;
}
public String getPublisher() {
return publisher;
}
public void setPublisher(String publisher) {
this.publisher = publisher;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public int getPublicationYear() {
return publicationYear;
}
public void setPublicationYear(int publicationYear) {
this.publicationYear = publicationYear;
}
@Override
public String toString() {
return "Book{" +
"idb=" + idb +
", title='" + title + '\'' +
", author='" + author + '\'' +
", category='" + category + '\'' +
", publisher='" + publisher + '\'' +
", publicationYear=" + publicationYear +
", description=" + description +
'}';
}
}
| true
|
795c7e15373ac8546a3ec5cdeb8d3bcb755e21eb
|
Java
|
thanhdat68/DuAn
|
/app/src/main/java/com/example/nhacmp3/Top20CSActivity.java
|
UTF-8
| 626
| 1.8125
| 2
|
[] |
no_license
|
package com.example.nhacmp3;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
public class Top20CSActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setTitle("Top 20 Ca Sĩ");
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
setContentView(R.layout.activity_top20_cs);
}
public void play(View view) {
Intent intent=new Intent(this,PlayActivity.class);
startActivity(intent);
}
}
| true
|
d410b34da526f5c6185dfa94148bc2cba098c8e3
|
Java
|
cckmit/sf_crm
|
/sf_crm/sf-job/src/main/java/com/shufensoft/crm/job/point/YzBuyPointJob.java
|
UTF-8
| 3,656
| 2.015625
| 2
|
[] |
no_license
|
package com.shufensoft.crm.job.point;
import com.github.pagehelper.PageInfo;
import com.shufensoft.crm.biz.constant.DaoConstant;
import com.shufensoft.crm.biz.domain.generation.seller.SellerConfigInfo;
import com.shufensoft.crm.biz.domain.generation.seller.SellerShop;
import com.shufensoft.crm.biz.domain.generation.trade.TradeYZ;
import com.shufensoft.crm.biz.service.pointmall.face.IPointService;
import com.shufensoft.crm.biz.service.trade.YouZanTradeService;
import com.shufensoft.crm.common.utils.SpringContextUtil;
import com.shufensoft.crm.constant.JobConstant;
import com.shufensoft.crm.job.base.BaseJob;
import com.shufensoft.crm.job.base.SyncDataJob;
import com.shufensoft.crm.job.context.JobContext;
import org.apache.commons.lang.time.DateUtils;
import org.apache.log4j.Logger;
import org.springframework.util.CollectionUtils;
import java.util.Date;
import java.util.List;
/**
*
* @ProjectName: sf-crm
* @Description: 根据淘宝订单产生购物积分
* @author zoujian zoujian@suniusoft.com
* @date 15/9/8 上午10:29
*/
public class YzBuyPointJob extends SyncDataJob {
/**
* logger
*/
private static final Logger logger = Logger.getLogger(BaseJob.class);
private static YouZanTradeService youZanTradeService;
private static IPointService pointService;
static {
youZanTradeService = (YouZanTradeService) SpringContextUtil.getBean("youZanTradeService");
pointService = (IPointService) SpringContextUtil.getBean("pointService");
}
@Override
public void _execute(JobContext jobContext) {
SellerConfigInfo sellerConfigInfo = jobContext.getSellerConfigInfo();
List<SellerShop> sellerShops = sellerConfigInfo.getSellerShopList();
for (SellerShop sellerShop : sellerShops) {
if (DaoConstant.ShopType.YZ.equals(sellerShop.getShopType())) {
try {
tradeYzToCreateBuyPoint(sellerShop);
} catch (Exception e) {
String messge = e.getMessage() == null ? " Null Pointer Exception" : e.getMessage();
logger.error(jobName == null ? "job" : jobName + " execute error,errorMag:" + messge, e);
saveJobLog(messge);
}
}
}
}
@Override
public String jobName() {
return JobConstant.JobName.YZ_TRADE_TO_BUYPOINT_JOB;
}
@Override
public boolean isChangeDataSoure() {
return true;
}
/**
* 同步有赞交易生成购物积分
*/
private void tradeYzToCreateBuyPoint(SellerShop sellerShop) {
/**
* 1.获取订单拉取起始时间
*/
Date startDate = this.getStartDate(sellerShop.getSellerId(), sellerShop.getShopId());
startDate = DateUtils.addDays(startDate, -5);
Date endDate = this.getEndDate(startDate);
/**
* 2.从trade_jz中拉取数据并计算产生购物积分。
*/
int start = 1;
while (true) {
PageInfo pageInfo = youZanTradeService.selectYzTradeListByDate(startDate, endDate, start, pageSize);
List<TradeYZ> tradeYZList = pageInfo.getList();
if (CollectionUtils.isEmpty(tradeYZList)) {
break;
}
for (TradeYZ tradeYZ : tradeYZList) {
pointService.tradeToCreateBuyPoint(sellerShop.getSellerId(), tradeYZ.getUserIdYz(), DaoConstant.UserSource.YZ, tradeYZ.getPayment().longValue(), Long.valueOf(tradeYZ.getTid().substring(1, tradeYZ.getTid().length())));
}
start++;
}
}
}
| true
|
1ea518f39a6421aec453edeba7abe5b96c759278
|
Java
|
gumuming/test_project
|
/src/main/java/com/gumm/project/test/config/LocalTimeDeserializer.java
|
UTF-8
| 1,073
| 2.5625
| 3
|
[] |
no_license
|
package com.gumm.project.test.config;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import java.io.IOException;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneOffset;
/**
*文本形式的时间戳,反序列化成LocalDate
*@author: Sara Karma
*@date: 2019/10/22
*/
public class LocalTimeDeserializer extends JsonDeserializer<LocalTime> {
public static final LocalTimeDeserializer INSTANCE;
static {
INSTANCE = new LocalTimeDeserializer();
}
private LocalTimeDeserializer() {
}
/**
* 当前时区偏移量
*/
private static final ZoneOffset CURRENT_ZONE_OFFSET = ZoneOffset.ofHours(8);
@Override
public LocalTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
return Instant.ofEpochMilli(Long.valueOf(jsonParser.getText())).atZone(CURRENT_ZONE_OFFSET).toLocalTime();
}
}
| true
|
aacec937e4af0f643f287ccf427240cecbc0b2da
|
Java
|
JulioAugusto9/sistemavendastcc-api
|
/sistemavendas-tcc/src/main/java/com/sistemavendastcc/domain/model/ItemPedido.java
|
UTF-8
| 1,582
| 2.25
| 2
|
[] |
no_license
|
package com.sistemavendastcc.domain.model;
import java.math.BigDecimal;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
@Entity
public class ItemPedido {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private BigDecimal preco;
private Long qtde;
@OneToOne
Produto produto;
@ManyToOne
Pedido pedido;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public BigDecimal getPreco() {
return preco;
}
public void setPreco(BigDecimal preco) {
this.preco = preco;
}
public Long getQtde() {
return qtde;
}
public void setQtde(Long qtde) {
this.qtde = qtde;
}
public Produto getProduto() {
return produto;
}
public void setProduto(Produto produto) {
this.produto = produto;
}
public Pedido getPedido() {
return pedido;
}
public void setPedido(Pedido pedido) {
this.pedido = pedido;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ItemPedido other = (ItemPedido) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
}
| true
|
1d2c257561af2cf231920a6629c3d413d8d93bd8
|
Java
|
BonzanigoMarco/FeedbackToFeedback
|
/android_library/feedbacklibrary/src/main/java/ch/uzh/supersede/feedbacklibrary/services/NotificationService.java
|
UTF-8
| 9,298
| 2.125
| 2
|
[
"Apache-2.0"
] |
permissive
|
package ch.uzh.supersede.feedbacklibrary.services;
import android.app.Notification;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.support.v4.app.NotificationManagerCompat;
import android.util.Log;
import java.util.List;
import ch.uzh.supersede.feedbacklibrary.R;
import ch.uzh.supersede.feedbacklibrary.beans.FeedbackDetailsBean;
import ch.uzh.supersede.feedbacklibrary.beans.LocalConfigurationBean;
import ch.uzh.supersede.feedbacklibrary.database.FeedbackDatabase;
import ch.uzh.supersede.feedbacklibrary.models.*;
import ch.uzh.supersede.feedbacklibrary.utils.*;
import static ch.uzh.supersede.feedbacklibrary.utils.Constants.EXTRA_KEY_APPLICATION_CONFIGURATION;
import static ch.uzh.supersede.feedbacklibrary.utils.Constants.UserConstants.USER_NAME;
import static ch.uzh.supersede.feedbacklibrary.utils.PermissionUtility.USER_LEVEL.ADVANCED;
public final class NotificationService extends Service implements IFeedbackServiceEventListener {
private static final int MAX_FAIL_COUNT = 10;
private LocalConfigurationBean configuration;
private String userName;
private int failCount = 0;
private int notificationId = 0;
private AsyncPoll asyncPoll;
private Thread pollThread;
@Override
public void onCreate() {
if (!ADVANCED.check(this)) {
stopSelf();
return;
}
if (configuration == null) {
configuration = FeedbackDatabase.getInstance(this).readConfiguration();
}
userName = FeedbackDatabase.getInstance(this).readString(USER_NAME, null);
if (CompareUtility.notNull(configuration, userName)) {
execStartAsyncPolling(configuration);
} else {
Log.e(getClass().getSimpleName(), "service stopped due to a configuration error.");
stopSelf();
}
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent != null) {
configuration = (LocalConfigurationBean) intent.getSerializableExtra(EXTRA_KEY_APPLICATION_CONFIGURATION);
}
Log.i(getClass().getSimpleName(), "service started.");
return START_STICKY;
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
/**
* Create a never dying service by re-instantiating itself through a brocastReciever when the actual host app gets destroyed.
*/
@Override
public void onTaskRemoved(Intent rootIntent) {
super.onTaskRemoved(rootIntent);
execStopAsyncPolling();
Intent broadcastIntent = new Intent(getResources().getString(R.string.notification_service_shutdown));
Log.d(getClass().getSimpleName(), "Starting new broadcast with configuration=" + (configuration != null));
sendBroadcast(broadcastIntent);
}
@Override
public void onDestroy() {
super.onDestroy();
execStopAsyncPolling();
}
private void execStopAsyncPolling() {
if (asyncPoll != null) {
resetFailCount();
asyncPoll.shutdown();
pollThread = null;
Log.i(getClass().getSimpleName(), "polling stopped.");
} else {
Log.d(getClass().getSimpleName(), "polling already stopped.");
}
}
protected void execSendNotification(Notification notification) {
if (notification != null) {
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
Log.d(this.getClass().getSimpleName(), "Notification #" + notificationId + " sent..");
notificationManager.notify(notificationId++, notification);
}
}
private void execStartAsyncPolling(LocalConfigurationBean config) {
asyncPoll = new AsyncPoll(config);
pollThread = new Thread(asyncPoll);
pollThread.start();
}
/**
* Executes the polling mechanism. The override of member variable configuration via the parameter config is necessary since, if ON_BOOT_COMPLETED triggers the BootCompletedReceiver creates a
* new instance of this class which will cause a discrepancy between Service and AsyncPoll such that the LocalConfigurationBean cannot be stored, and thus is indeed null.
*
* @param config configuration that passed by Service through AsyncPoll
* @see BootCompletedReceiver
*/
void execPoll(LocalConfigurationBean config) {
if (configuration == null) {
configuration = config;
}
if (failCount > MAX_FAIL_COUNT) {
resetFailCount();
stopSelf();
return;
}
if (FeedbackService.getInstance(this).isAuthenticated()) {
FeedbackService.getInstance(this).getFeedbackListSubscribed(this, this);
FeedbackService.getInstance(this).getUser(this, new AndroidUser(userName));
} else {
FeedbackService.getInstance(this).authenticate(this, new AuthenticateRequest(config.getEndpointLogin(), config.getEndpointPass()));
}
}
@Override
public void onEventCompleted(IFeedbackServiceEventListener.EventType eventType, Object response) {
switch (eventType) {
case AUTHENTICATE:
if (response instanceof AuthenticateResponse) {
FeedbackService.getInstance(this).setToken(((AuthenticateResponse) response).getToken());
}
break;
case GET_FEEDBACK_LIST_SUBSCRIBED:
List<FeedbackDetailsBean> feedbackDetailsBeans = FeedbackUtility.transformFeedbackResponse(response, this);
handleFeedbackSubscriptionUpdate(feedbackDetailsBeans);
break;
case GET_USER:
if (response instanceof AndroidUser) {
handleUserUpdate((AndroidUser) response);
}
break;
case GET_FEEDBACK_LIST_SUBSCRIBED_MOCK:
execSendNotification(NotificationUtility.getInstance(this).createDummyFeedbackUpdateNotification(this, configuration));
break;
case GET_USER_MOCK:
execSendNotification(NotificationUtility.getInstance(this).createDummyUserUpdateNotification(this, configuration));
break;
default:
break;
}
}
private void handleFeedbackSubscriptionUpdate(List<FeedbackDetailsBean> newFeedbackDetailsBeans) {
List<Notification> notifications = NotificationUtility.getInstance(this).createFeedbackUpdateNotification(newFeedbackDetailsBeans, this, configuration, true);
for (Notification notification : notifications) {
execSendNotification(notification);
}
}
private void handleUserUpdate(AndroidUser androidUser) {
List<Notification> notifications = NotificationUtility.getInstance(this).createUserUpdateNotification(androidUser, this, configuration, true);
for (Notification notification : notifications) {
execSendNotification(notification);
}
}
@Override
public void onEventFailed(IFeedbackServiceEventListener.EventType eventType, Object response) {
updateFailCount();
Log.w(getClass().getSimpleName(), getResources().getString(R.string.api_service_event_failed, eventType, response.toString()));
}
@Override
public void onConnectionFailed(IFeedbackServiceEventListener.EventType eventType) {
updateFailCount();
Log.w(getClass().getSimpleName(), getResources().getString(R.string.api_service_connection_failed, eventType));
}
private synchronized void updateFailCount() {
failCount++;
}
private synchronized void resetFailCount() {
failCount = 0;
}
/**
* Async task that creates a new thread which periodically calls ansync functions of enclosing class.
* Runs forever until destory of enclosing class or calling task.shutdown().
*/
@SuppressWarnings("squid:S2209")
public class AsyncPoll implements Runnable {
private boolean isShutdown = false;
private LocalConfigurationBean config;
AsyncPoll(LocalConfigurationBean config) {
this.config = config;
}
@Override
public void run() {
Thread thisThread = Thread.currentThread();
while (pollThread == thisThread) {
execPoll(config);
try {
Thread.sleep(DateUtility.minutesToMillis(config.getPullIntervalMinutes()));
synchronized (this) {
while (isShutdown && pollThread == thisThread) {
wait();
}
}
} catch (InterruptedException e) {
Log.e(this.getClass().getSimpleName(), e.getMessage(), e);
thisThread.interrupt();
}
}
}
synchronized void shutdown() {
resetFailCount();
asyncPoll = null;
isShutdown = true;
synchronized (this) {
notifyAll();
}
}
}
}
| true
|
b790d4453b98213935cb4356262c6b461a29b5b0
|
Java
|
XurajB/data_structure_algorithms
|
/src/problems/math/MatrixMultiplication.java
|
UTF-8
| 2,981
| 3.625
| 4
|
[] |
no_license
|
package problems.math;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* Given two sparse matrices A and B, return the result of AB.
* https://leetcode.com/problems/sparse-matrix-multiplication/
*/
public class MatrixMultiplication {
public static void main(String[] args) {
int[][] A = new int[][] {
{1, 0, 0},
{-1, 0, 3}
};
int[][] B = new int[][] {
{7,0,0},
{0,0,1},
{0,0,1}
};
int[][] ans = multiply(A, B);
for (int[] a: ans) {
System.out.println(Arrays.toString(a));
}
}
private static int[][] multiply(int[][] A, int[][] B) {
// result size: A row. B col
// A col should have same size as B row
int n1 = A.length;
int m1 = B[0].length;
int[][] answer = new int[n1][m1];
for (int i = 0; i < n1; i++) {
int[] row = A[i];
for (int j = 0; j < m1; j++) {
int sum = 0;
for (int k = 0; k < row.length; k++) {
sum = sum + row[k] * B[k][j];
}
answer[i][j] = sum;
}
}
return answer;
}
// sparse matrix compression
private int[][] multiply2(int[][] A, int[][] B) {
if (A.length == 0 || A[0].length == 0
|| B .length == 0 || B[0].length == 0) {
return new int[][] {};
}
int r = A.length;
int c = A[0].length;
int cB = B[0].length;
int[][] ans = new int[r][cB];
Map<Integer, Map<Integer, Integer>> map = new HashMap<>(); // row, (col, val)
// compress
for (int i = 0; i < r; i++) {
Map<Integer, Integer> temp = new HashMap<>();
for (int j = 0; j < c; j++) {
if (A[i][j] != 0) {
temp.put(j, A[i][j]);
}
}
map.put(i, temp);
}
// multiply, similar to above but use map for matrix A
for (int key1: map.keySet()) {
for (int i = 0; i < cB; i++) {
for (int key2: map.get(key1).keySet()) {
ans[key1][i] += map.get(key1).get(key2) * B[key2][i];
}
}
}
return ans;
}
////////
// if sparse matrix
private int[][] multiply3(int[][] A, int[][] B) {
int rA = A.length;
int cA = A[0].length;
int cB = B[0].length;
int[][] ans = new int[rA][cB];
for (int i = 0; i < rA; i++) {
for (int j = 0; j < cA; j++) {
if (A[i][j] != 0) {
for (int k = 0; k < cB; k++) {
if (B[j][k] != 0) {
ans[i][k] += A[i][j] * B[j][k];
}
}
}
}
}
return ans;
}
}
| true
|
253a2e4d3b55ead98d248885db79b780ea71c745
|
Java
|
hitechr/garobo
|
/garobo-common/src/main/java/org/hitechr/garobo/common/entity/Response.java
|
UTF-8
| 1,282
| 2.546875
| 3
|
[
"Apache-2.0"
] |
permissive
|
package org.hitechr.garobo.common.entity;
/**
* @Package org.hitechr.garobo.model
* @Title: Response
* @author hitechr
* @date 2018/8/1 15:58
* @version V1.0
*/
import lombok.Getter;
import lombok.Setter;
import java.util.Date;
/**
* @Descriptions:
*/
@Getter
@Setter
public class Response {
private String result;
private int exitValue;
@Getter
private int status;
private Date startDate;
private Date endDate;
public Response(){}
public Response(Status status) {
this.status = status.getCode();
}
public Response(String result, Status status) {
this.result = result;
this.status = status.getCode();
}
@Override
public String toString() {
return "Response{" +
"result='" + result + '\'' +
", exitValue=" + exitValue +
", status=" + status +
", startDate=" + startDate +
", endDate=" + endDate +
'}';
}
public enum Status{
SUCCESS(0),
FAIL(1),
ERROR(2),
NULL(3),
EXIST(4);
int code;
Status(int code) {
this.code = code;
}
public int getCode() {
return code;
}
}
}
| true
|
fd74604276d000f455530bfc5a8b42fa06b3a291
|
Java
|
SkytAsul/BeautyQuests
|
/core/src/main/java/fr/skytasul/quests/editors/CancellableEditor.java
|
UTF-8
| 743
| 2.484375
| 2
|
[
"MIT"
] |
permissive
|
package fr.skytasul.quests.editors;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.player.PlayerInteractEvent;
import fr.skytasul.quests.gui.ItemUtils;
public abstract class CancellableEditor extends InventoryClear {
public CancellableEditor(Player p, Runnable cancel) {
super(p, cancel);
}
@EventHandler (priority = EventPriority.LOW)
public void onClick(PlayerInteractEvent e) {
if (e.getPlayer() != p) return;
if (ItemUtils.itemCancel.equals(e.getItem())) {
e.setCancelled(true);
cancel();
}
}
@Override
public void begin() {
super.begin();
if (cancel != null) p.getInventory().setItem(8, ItemUtils.itemCancel);
}
}
| true
|
b1c19d4907ec4aa480c32471934fa2575fec7401
|
Java
|
grunk/design_patterns
|
/exemples/implement_extends/src/fr/oroger/Animal.java
|
UTF-8
| 482
| 3.65625
| 4
|
[] |
no_license
|
package fr.oroger;
class Animal {
private String name;
private String color;
private float weight;
public Animal(String name, String color, float weight) {
this.name = name;
this.color = color;
this.weight = weight;
}
public void run()
{
System.out.println(this.name+"is Running");
}
}
class Cat extends Animal{
public Cat(String name, String color, float weight) {
super(name, color, weight);
}
}
| true
|
2cbf7e411779915b0dd0a6ab36ee020b40f1c101
|
Java
|
roxov/feteforaine
|
/src/fr/asterox/feteforaine/stands/Stands.java
|
UTF-8
| 192
| 1.796875
| 2
|
[] |
no_license
|
package fr.asterox.feteforaine.stands;
import fr.asterox.feteforaine.core.Accessible;
public interface Stands extends Accessible {
public String getName() ;
public char getLetter() ;
}
| true
|
62b04642441dd7a52cc3c74106374ecfe9619f38
|
Java
|
Quadtree/LD26
|
/core/src/main/java/com/ironalloygames/planetfall/core/unit/HexapedDeer.java
|
UTF-8
| 898
| 2.796875
| 3
|
[] |
no_license
|
package com.ironalloygames.planetfall.core.unit;
import playn.core.Color;
import com.ironalloygames.planetfall.core.PFG;
import com.ironalloygames.planetfall.core.item.RawMeat;
import com.ironalloygames.planetfall.core.level.Level;
public class HexapedDeer extends Unit {
@Override
public void render() {
PFG.s.setCharAtReal(x, y, 'D', fixCol(Color.rgb(128, 255, 0)));
super.render();
}
@Override
public void destroyed() {
curLevel.actors.add(new RawMeat(x,y,curLevel));
curLevel.actors.add(new RawMeat(x,y,curLevel));
super.destroyed();
}
@Override
public String getDesc() {
return "Like a regular deer, except that it has six legs! Seems docile, though.";
}
public HexapedDeer(int x, int y, Level lvl){
this.x = x;
this.y = y;
this.curLevel = lvl;
}
@Override
public String getName() {
return "Hexaped Deer";
}
}
| true
|
7a04e8b2d3ce3d7805b9f15a76ca4125dc9ab879
|
Java
|
pratiktimer/Fabquiz
|
/app/src/main/java/google/com/fabquiz/Login/User.java
|
UTF-8
| 1,087
| 2.203125
| 2
|
[
"Apache-2.0"
] |
permissive
|
package google.com.fabquiz.Login;
/**
* Created by Pratik on 2/23/2018.
*/
public class User {
String phonenumber;
String fullname;
String getprofile;
String userId;
public User() {
}
public User(String phonenumber, String fullname, String getprofile, String userId) {
this.phonenumber = phonenumber;
this.fullname = fullname;
this.getprofile = getprofile;
this.userId = userId;
}
public String getPhonenumber() {
return phonenumber;
}
public void setPhonenumber(String phonenumber) {
this.phonenumber = phonenumber;
}
public String getFullname() {
return fullname;
}
public void setFullname(String fullname) {
this.fullname = fullname;
}
public String getGetprofile() {
return getprofile;
}
public void setGetprofile(String getprofile) {
this.getprofile = getprofile;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
}
| true
|
4fdf1dcc5d67bf596f01e320a2dfae526634d22a
|
Java
|
luisrojash/BoxMadikApp
|
/app/src/main/java/com/application/boxmadikv1/registraUser/dialog/DatePickerDialogTheme.java
|
UTF-8
| 1,101
| 2.3125
| 2
|
[] |
no_license
|
package com.application.boxmadikv1.registraUser.dialog;
import android.app.AlertDialog;
import android.app.DatePickerDialog;
import android.app.Dialog;
import android.os.Bundle;
import androidx.fragment.app.DialogFragment;
import android.widget.DatePicker;
import java.util.Calendar;
public class DatePickerDialogTheme extends DialogFragment implements DatePickerDialog.OnDateSetListener{
@Override
public Dialog onCreateDialog(Bundle savedInstanceState){
final Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int day = calendar.get(Calendar.DAY_OF_MONTH);
DatePickerDialog datepickerdialog = new DatePickerDialog(getActivity(),
AlertDialog.THEME_HOLO_DARK,this,year,month,day);
return datepickerdialog;
}
public void onDateSet(DatePicker view, int year, int month, int day){
/* TextView textview = (TextView)getActivity().findViewById(R.id.textView1);
textview.setText(day + ":" + (month+1) + ":" + year);*/
}
}
| true
|
92d130439d37166ffeec7291bab5a1219f09133b
|
Java
|
ivarcode/ChessGame
|
/ChessGame/src/net/ivarcode/camden/piece/Pawn.java
|
UTF-8
| 322
| 2.484375
| 2
|
[] |
no_license
|
package net.ivarcode.camden.piece;
import java.awt.image.BufferedImage;
import net.ivarcode.camden.Location;
public class Pawn extends Piece {
public Pawn(Location loc, String color, BufferedImage img) {
super(loc, color, img);
setID("Pawn");
setPointValue(1);
}
public Pawn() {
//null constructor
}
}
| true
|
d3105175a1062d9c0340037c9022860f0b144091
|
Java
|
nadee158/eventsapp
|
/sportsman/services-business/src/main/java/com/janaka/projects/services/common/NotificationService.java
|
UTF-8
| 804
| 1.84375
| 2
|
[] |
no_license
|
package com.janaka.projects.services.common;
import com.janaka.projects.common.security.AuditContext;
import com.janaka.projects.common.security.SecurityContext;
import com.janaka.projects.dtos.requests.common.SendEmailRequest;
import com.janaka.projects.dtos.requests.common.SendSMSRequest;
import com.janaka.projects.dtos.responses.common.SendEmailResponse;
import com.janaka.projects.dtos.responses.common.SendSMSResponse;
public interface NotificationService {
public SendEmailResponse sendEmail(SendEmailRequest request, AuditContext auditContext,
SecurityContext securityContext);
public void reSendEmails();
public SendSMSResponse sendSMS(SendSMSRequest request, AuditContext auditContext, SecurityContext securityContext);
public void reSendSmses();
}
| true
|
6ce899577a4f32e965bbfc764c56ef1c07fb1fe1
|
Java
|
clicktabs/X12Healthcare
|
/src/main/java/com/xiaoerge/x12/message/segment/ST.java
|
UTF-8
| 1,053
| 2.171875
| 2
|
[
"Apache-2.0",
"Beerware"
] |
permissive
|
package com.xiaoerge.x12.message.segment;
import com.xiaoerge.x12.annotation.Declaration;
import com.xiaoerge.x12.annotation.Definition;
import com.xiaoerge.x12.message.MessageFormat;
/**
* Created by xiaoerge on 5/23/16.
*/
@Declaration(fieldSize = 3, name = "ST")
public class ST extends Segment {
public ST() {super();}
public ST(String content, MessageFormat mf) {
super(content, mf);
}
@Definition(position = 1, minLength = 3, maxLength = 3)
public String getTransactionSetIDCode() { return getField(1); }
@Definition(position = 2, minLength = 4, maxLength = 9)
public String getTransactionSetControlNumber() { return getField(2); }
@Definition(position = 3, minLength = 1, maxLength = 35)
public String getImplementationConventionReference() { return getField(3); }
public void setTransactionSetIDCode(String s) { setField(1,s); }
public void setTransactionSetControlNumber(String s) { setField(2,s); }
public void setImplementationConventionReference(String s) { setField(3,s); }
}
| true
|
b888e509de9efa83dd4a1b72549d239bab89f10b
|
Java
|
gaochongfei/SSM
|
/socketFront/src/cn/newcapec/chat/server/net/s2c/S2C4005.java
|
UTF-8
| 589
| 2.03125
| 2
|
[] |
no_license
|
package cn.newcapec.chat.server.net.s2c;
import org.jboss.netty.buffer.ChannelBuffer;
//4005
public class S2C4005 extends S2CMsg {
public S2C4005() {
super(4005);
}
public void write(ChannelBuffer buffer) throws Exception {
writeUTF8(sFileInfo.fileSize,buffer);
writeUTF8(sFileInfo.resultCode4005,buffer);
}
public String toString() {
String toStr="";
toStr+="fileSize:"+sFileInfo.fileSize+", ";
toStr+="resultCode:"+sFileInfo.resultCode4005+", ";
if(toStr.lastIndexOf(",") != -1){
toStr = toStr.substring(0, toStr.lastIndexOf(","));
}
return toStr;
}
}
| true
|
467093d88c7ab99dfb87f7df5830679ebc2e943c
|
Java
|
lgpbentes/AplicacaoSMARTe
|
/app/src/main/java/com/example/lgpbentes/aplicacaosmarte/AlarmeActivity.java
|
UTF-8
| 2,208
| 2.1875
| 2
|
[] |
no_license
|
package com.example.lgpbentes.aplicacaosmarte;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.SystemClock;
import android.os.Vibrator;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;
import java.io.Console;
public class AlarmeActivity extends AppCompatActivity implements View.OnClickListener {
final static private long ONE_SECOND = 1000;
final static private long TWENTY_SECONDS = ONE_SECOND * 10;
PendingIntent pi;
BroadcastReceiver br;
AlarmManager am;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_alarme);
setup();
findViewById(R.id.the_button).setOnClickListener(this);
}
@Override
public void onClick(View v) {
Toast.makeText(this, "Clicado!", Toast.LENGTH_LONG).show();
am.set( AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() +
TWENTY_SECONDS, pi );
}
private void setup() {
br = new BroadcastReceiver() {
@Override
public void onReceive(Context c, Intent i) {
//Toast.makeText(c, "Rise and Shine!", Toast.LENGTH_LONG).show();
// Get instance of Vibrator from current Context
Vibrator mVibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
// Vibrate for 300 milliseconds
mVibrator.vibrate(300);
}
};
registerReceiver(br, new IntentFilter("com.example.lgpbentes.aplicacaosmarte.TelaNotificacao") );
pi = PendingIntent.getBroadcast( this, 0, new Intent("com.example.lgpbentes.aplicacaosmarte.TelaNotificacao"),
0 );
am = (AlarmManager)(this.getSystemService( Context.ALARM_SERVICE ));
}
@Override
protected void onDestroy() {
am.cancel(pi);
unregisterReceiver(br);
super.onDestroy();
}
}
| true
|
fccdb809b138be98c217b1ae017bd306f52250d8
|
Java
|
lishihui/test
|
/src/com/module/domain/base/ZTree.java
|
UTF-8
| 2,390
| 2
| 2
|
[] |
no_license
|
package com.module.domain.base;
public class ZTree implements java.io.Serializable {
private static final long serialVersionUID = -3839946904766584505L;
private String id;//ID
private String uuid;//除ID外的唯一值
private String name;//显示名
private boolean checked = false;//是否选中
private boolean open;
private String pId;//上级id 不用全小写因为ZTREE JS组件问题
private String classflag;//是否分类目录 扫描模块使用
private String pagnum;//是否分类目录 扫描模块使用
private boolean nocheck = false;//是否显示可选
private String menuaction="";//菜单URL
private String level;//级别
private String menuState;//状态
private String sortnum;//排序
public String getClassflag() {
return classflag;
}
public void setClassflag(String classflag) {
this.classflag = classflag;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isChecked() {
return checked;
}
public void setChecked(boolean checked) {
this.checked = checked;
}
public boolean isOpen() {
return open;
}
public void setOpen(boolean open) {
this.open = open;
}
public String getpId() {
return pId;
}
public void setpId(String pId) {
this.pId = pId;
}
public String getUuid() {
return uuid;
}
public void setUuid(String uuid) {
this.uuid = uuid;
}
public String getPagnum() {
return pagnum;
}
public void setPagnum(String pagnum) {
this.pagnum = pagnum;
}
public boolean isNocheck() {
return nocheck;
}
public void setNocheck(boolean nocheck) {
this.nocheck = nocheck;
}
public String getMenuaction() {
return menuaction;
}
public void setMenuaction(String menuaction) {
this.menuaction = menuaction;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public String getMenuState() {
return menuState;
}
public void setMenuState(String menuState) {
this.menuState = menuState;
}
public String getSortnum() {
return sortnum;
}
public void setSortnum(String sortnum) {
this.sortnum = sortnum;
}
}
| true
|
757dbcaf32a4c20e4dd8536362a29b2656befccf
|
Java
|
sunyton/Stage1stPlus
|
/app/src/main/java/com/code4job/suny/stage1st/adapter/MyPagerAdapter.java
|
UTF-8
| 1,036
| 2.140625
| 2
|
[] |
no_license
|
package com.code4job.suny.stage1st.adapter;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentPagerAdapter;
import android.support.v4.view.PagerAdapter;
import android.view.View;
import com.code4job.suny.stage1st.fragment.FragmentRv;
import java.util.List;
/**
* Created by suny on 2017/6/16.
*/
public class MyPagerAdapter extends FragmentPagerAdapter {
private List<FragmentRv> mFragmentRvs;
private List<String> titleList;
public MyPagerAdapter(FragmentManager fm,List<FragmentRv> mFragmentRvs, List<String> titleList) {
super(fm);
this.mFragmentRvs = mFragmentRvs;
this.titleList = titleList;
}
@Override
public Fragment getItem(int position) {
return mFragmentRvs.get(position);
}
@Override
public int getCount() {
return mFragmentRvs.size();
}
@Override
public CharSequence getPageTitle(int position) {
return titleList.get(position);
}
}
| true
|
f546ab4bd0b90f94ccef1ac662c0ff202df31aeb
|
Java
|
STAMP-project/Cling-application
|
/results/randoop5/time-org.joda.time.MutableDateTime-5/RegressionTest3.java
|
UTF-8
| 1,379,219
| 2.328125
| 2
|
[] |
no_license
|
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.Ignore;
import org.junit.runners.MethodSorters;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class RegressionTest3 {
public static boolean debug = false;
@Test
@Ignore
public void test1501() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1501");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime13.dayOfWeek();
int int15 = property14.getMinimumValueOverall();
org.joda.time.MutableDateTime mutableDateTime16 = property14.roundFloor();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime19.add(readablePeriod22);
org.joda.time.MutableDateTime.Property property24 = mutableDateTime19.hourOfDay();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime19.dayOfWeek();
int int26 = property25.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime28 = property25.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime29 = property25.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime30 = property25.roundHalfFloor();
mutableDateTime30.addMinutes(40);
int int33 = property14.compareTo((org.joda.time.ReadableInstant) mutableDateTime30);
mutableDateTime30.add((long) 6494370);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:58.319Z" + "'", str4, "2020-11-25T01:48:58.319Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 1 + "'", int15 == 1);
org.junit.Assert.assertNotNull(mutableDateTime16);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:48:58.319Z" + "'", str21, "2020-11-25T01:48:58.319Z");
org.junit.Assert.assertNotNull(property24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 7 + "'", int26 == 7);
org.junit.Assert.assertNotNull(mutableDateTime28);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 0 + "'", int33 == 0);
}
@Test
public void test1502() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1502");
org.joda.time.format.DateTimeFormatter dateTimeFormatter1 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime2 = org.joda.time.MutableDateTime.parse("2020-11-25T01:47:08.162Z", dateTimeFormatter1);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1503() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1503");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
int int6 = mutableDateTime3.getYearOfCentury();
org.joda.time.Chronology chronology7 = mutableDateTime3.getChronology();
int int8 = mutableDateTime3.getWeekOfWeekyear();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.DateTimeZone dateTimeZone12 = mutableDateTime11.getZone();
org.joda.time.DateTime dateTime13 = mutableDateTime3.toDateTime(dateTimeZone12);
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((-1L), dateTimeZone12);
org.joda.time.DateTime dateTime15 = mutableDateTime14.toDateTimeISO();
int int16 = dateTime15.getYearOfCentury();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:48:58.441Z" + "'", str5, "2020-11-25T01:48:58.441Z");
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 20 + "'", int6 == 20);
org.junit.Assert.assertNotNull(chronology7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 48 + "'", int8 == 48);
org.junit.Assert.assertNotNull(dateTimeZone12);
org.junit.Assert.assertNotNull(dateTime13);
org.junit.Assert.assertNotNull(dateTime15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 69 + "'", int16 == 69);
}
@Test
@Ignore
public void test1504() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1504");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
int int4 = mutableDateTime2.getSecondOfMinute();
int int5 = mutableDateTime2.getMonthOfYear();
int int6 = mutableDateTime2.getMillisOfSecond();
int int7 = mutableDateTime2.getMinuteOfHour();
int int8 = mutableDateTime2.getDayOfMonth();
int int9 = mutableDateTime2.getDayOfWeek();
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 58 + "'", int4 == 58);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 11 + "'", int5 == 11);
// flaky: org.junit.Assert.assertTrue("'" + int6 + "' != '" + 493 + "'", int6 == 493);
// flaky: org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 25 + "'", int8 == 25);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 3 + "'", int9 == 3);
}
@Test
@Ignore
public void test1505() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1505");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.centuryOfEra();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.hourOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime12.dayOfWeek();
int int19 = property18.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
int int22 = mutableDateTime21.getYearOfCentury();
boolean boolean23 = property9.equals((java.lang.Object) mutableDateTime21);
boolean boolean25 = property9.equals((java.lang.Object) "2020-11-25T01:45:15.023Z");
java.lang.String str26 = property9.getAsString();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:58.552Z" + "'", str4, "2020-11-25T01:48:58.552Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:48:58.552Z" + "'", str14, "2020-11-25T01:48:58.552Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 7 + "'", int19 == 7);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "20" + "'", str26, "20");
}
@Test
@Ignore
public void test1506() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1506");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property15.add(2189);
java.lang.String str18 = mutableDateTime17.toString();
int int19 = mutableDateTime17.getDayOfYear();
int int20 = mutableDateTime17.getDayOfYear();
java.util.Locale locale21 = null;
java.util.Calendar calendar22 = mutableDateTime17.toCalendar(locale21);
org.joda.time.DateTime dateTime23 = mutableDateTime17.toDateTime();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:58.593Z" + "'", str4, "2020-11-25T01:48:58.593Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T02:25:27.593Z" + "'", str18, "2020-11-25T02:25:27.593Z");
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 330 + "'", int19 == 330);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 330 + "'", int20 == 330);
org.junit.Assert.assertNotNull(calendar22);
// flaky: org.junit.Assert.assertEquals(calendar22.toString(), "java.util.GregorianCalendar[time=1606271127593,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=25,DAY_OF_YEAR=330,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=2,HOUR_OF_DAY=2,MINUTE=25,SECOND=27,MILLISECOND=593,ZONE_OFFSET=0,DST_OFFSET=0]");
org.junit.Assert.assertNotNull(dateTime23);
}
@Test
public void test1507() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1507");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = property3.roundCeiling();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime4.minuteOfHour();
org.joda.time.DateTimeField dateTimeField6 = property5.getField();
int int7 = property5.getMinimumValue();
java.lang.String str8 = property5.getAsString();
org.joda.time.MutableDateTime mutableDateTime9 = property5.roundHalfEven();
int int10 = property5.getMaximumValueOverall();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(dateTimeField6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "0" + "'", str8, "0");
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 59 + "'", int10 == 59);
}
@Test
public void test1508() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1508");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
boolean boolean10 = mutableDateTime9.isEqualNow();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime9.dayOfMonth();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.Instant instant15 = mutableDateTime14.toInstant();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime14.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime17 = property16.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime18 = mutableDateTime17.toMutableDateTime();
org.joda.time.MutableDateTime.Property property19 = mutableDateTime17.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime21 = property19.set(49);
org.joda.time.MutableDateTime mutableDateTime22 = property19.roundHalfFloor();
org.joda.time.DateTimeFieldType dateTimeFieldType23 = property19.getFieldType();
int int24 = property19.getMaximumValue();
org.joda.time.DateTimeFieldType dateTimeFieldType25 = property19.getFieldType();
// The following exception was thrown during execution in test generation
try {
mutableDateTime9.set(dateTimeFieldType25, 106);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 106 for yearOfCentury must be in the range [0,99]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(instant15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(dateTimeFieldType23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 99 + "'", int24 == 99);
org.junit.Assert.assertNotNull(dateTimeFieldType25);
}
@Test
@Ignore
public void test1509() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1509");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime13.add(readablePeriod14, 40);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime13.toMutableDateTime(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 100, chronology23);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime25.dayOfYear();
java.lang.String str27 = property26.getAsShortText();
long long28 = property26.remainder();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:48:58.858Z" + "'", str5, "2020-11-25T01:48:58.858Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:48:58.858Z" + "'", str21, "2020-11-25T01:48:58.858Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertEquals("'" + str27 + "' != '" + "1" + "'", str27, "1");
org.junit.Assert.assertTrue("'" + long28 + "' != '" + 100L + "'", long28 == 100L);
}
@Test
@Ignore
public void test1510() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1510");
java.lang.Object obj2 = null;
org.joda.time.Chronology chronology3 = null;
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime(obj2, chronology3);
org.joda.time.format.DateTimeFormatter dateTimeFormatter5 = null;
java.lang.String str6 = mutableDateTime4.toString(dateTimeFormatter5);
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime4.add(readablePeriod7);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime4.hourOfDay();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime4.dayOfWeek();
int int11 = property10.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime13 = property10.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime14 = property10.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime14.add(readablePeriod15, 40);
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
org.joda.time.Chronology chronology24 = mutableDateTime20.getChronology();
org.joda.time.MutableDateTime mutableDateTime25 = mutableDateTime14.toMutableDateTime(chronology24);
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(6436228L, chronology24);
org.joda.time.MutableDateTime mutableDateTime27 = org.joda.time.MutableDateTime.now(chronology24);
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:48:29.646Z", chronology24);
// flaky: org.junit.Assert.assertEquals("'" + str6 + "' != '" + "2020-11-25T01:48:58.886Z" + "'", str6, "2020-11-25T01:48:58.886Z");
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 7 + "'", int11 == 7);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(mutableDateTime14);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:48:58.886Z" + "'", str22, "2020-11-25T01:48:58.886Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(chronology24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(mutableDateTime27);
}
@Test
public void test1511() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1511");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.minuteOfHour();
int int14 = property13.getLeapAmount();
int int15 = property13.getMinimumValueOverall();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:58.937Z" + "'", str4, "2020-11-25T01:48:58.937Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
}
@Test
public void test1512() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1512");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
int int4 = mutableDateTime2.getSecondOfMinute();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.yearOfEra();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 0 + "'", int4 == 0);
org.junit.Assert.assertNotNull(property5);
}
@Test
public void test1513() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1513");
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(64, 263, 6528, 787, 2020, 107, 7);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 787 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
}
@Test
public void test1514() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1514");
org.joda.time.format.DateTimeFormatter dateTimeFormatter1 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime2 = org.joda.time.MutableDateTime.parse("2020-11-25T01:47:28.704Z", dateTimeFormatter1);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1515() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1515");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
int int6 = mutableDateTime2.getCenturyOfEra();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
int int10 = mutableDateTime9.getDayOfWeek();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.DateTimeZone dateTimeZone14 = mutableDateTime13.getZone();
org.joda.time.MutableDateTime mutableDateTime15 = org.joda.time.MutableDateTime.now(dateTimeZone14);
mutableDateTime9.setZoneRetainFields(dateTimeZone14);
org.joda.time.DateTime dateTime17 = mutableDateTime2.toDateTime(dateTimeZone14);
org.joda.time.MutableDateTime mutableDateTime18 = org.joda.time.MutableDateTime.now(dateTimeZone14);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(dateTimeZone14);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 19 + "'", int6 == 19);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 3 + "'", int10 == 3);
org.junit.Assert.assertNotNull(dateTimeZone14);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertNotNull(dateTime17);
org.junit.Assert.assertNotNull(mutableDateTime18);
}
@Test
public void test1516() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1516");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType8 = property7.getFieldType();
org.joda.time.DateTimeFieldType dateTimeFieldType9 = property7.getFieldType();
long long10 = property7.remainder();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.120Z" + "'", str4, "2020-11-25T01:48:59.120Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeFieldType8);
org.junit.Assert.assertNotNull(dateTimeFieldType9);
// flaky: org.junit.Assert.assertTrue("'" + long10 + "' != '" + 2939120L + "'", long10 == 2939120L);
}
@Test
@Ignore
public void test1517() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1517");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property3.add((long) (short) -1);
java.util.Locale locale6 = null;
int int7 = property3.getMaximumShortTextLength(locale6);
long long8 = property3.remainder();
org.joda.time.MutableDateTime mutableDateTime9 = property3.getMutableDateTime();
int int10 = property3.getMinimumValue();
org.joda.time.MutableDateTime mutableDateTime11 = property3.roundFloor();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 3 + "'", int7 == 3);
org.junit.Assert.assertTrue("'" + long8 + "' != '" + 1L + "'", long8 == 1L);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 1 + "'", int10 == 1);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
@Test
@Ignore
public void test1518() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1518");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
mutableDateTime3.setTime((long) '#');
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
java.lang.String str16 = mutableDateTime10.toString();
int int17 = mutableDateTime3.compareTo((org.joda.time.ReadableInstant) mutableDateTime10);
org.joda.time.MutableDateTime mutableDateTime18 = mutableDateTime3.copy();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
int int24 = mutableDateTime21.getYearOfCentury();
org.joda.time.Chronology chronology25 = mutableDateTime21.getChronology();
org.joda.time.MutableDateTime mutableDateTime26 = org.joda.time.MutableDateTime.now(chronology25);
org.joda.time.MutableDateTime mutableDateTime27 = mutableDateTime3.toMutableDateTime(chronology25);
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
mutableDateTime30.setTime((long) '#');
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
org.joda.time.ReadablePeriod readablePeriod40 = null;
mutableDateTime37.add(readablePeriod40);
org.joda.time.MutableDateTime.Property property42 = mutableDateTime37.hourOfDay();
java.lang.String str43 = mutableDateTime37.toString();
int int44 = mutableDateTime30.compareTo((org.joda.time.ReadableInstant) mutableDateTime37);
org.joda.time.MutableDateTime mutableDateTime45 = mutableDateTime30.copy();
java.lang.Object obj46 = null;
org.joda.time.Chronology chronology47 = null;
org.joda.time.MutableDateTime mutableDateTime48 = new org.joda.time.MutableDateTime(obj46, chronology47);
org.joda.time.format.DateTimeFormatter dateTimeFormatter49 = null;
java.lang.String str50 = mutableDateTime48.toString(dateTimeFormatter49);
int int51 = mutableDateTime48.getYearOfCentury();
org.joda.time.Chronology chronology52 = mutableDateTime48.getChronology();
org.joda.time.MutableDateTime mutableDateTime53 = org.joda.time.MutableDateTime.now(chronology52);
org.joda.time.MutableDateTime mutableDateTime54 = mutableDateTime30.toMutableDateTime(chronology52);
org.joda.time.DateTime dateTime55 = mutableDateTime3.toDateTime(chronology52);
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime((long) 376, chronology52);
// The following exception was thrown during execution in test generation
try {
mutableDateTime56.setMonthOfYear(6469);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6469 for monthOfYear must be in the range [1,12]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:48:59.180Z" + "'", str5, "2020-11-25T01:48:59.180Z");
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:48:59.180Z" + "'", str12, "2020-11-25T01:48:59.180Z");
org.junit.Assert.assertNotNull(property15);
// flaky: org.junit.Assert.assertEquals("'" + str16 + "' != '" + "2020-11-25T01:48:59.180Z" + "'", str16, "2020-11-25T01:48:59.180Z");
org.junit.Assert.assertTrue("'" + int17 + "' != '" + (-1) + "'", int17 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime18);
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:48:59.180Z" + "'", str23, "2020-11-25T01:48:59.180Z");
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 20 + "'", int24 == 20);
org.junit.Assert.assertNotNull(chronology25);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(mutableDateTime27);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:48:59.181Z" + "'", str32, "2020-11-25T01:48:59.181Z");
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:48:59.181Z" + "'", str39, "2020-11-25T01:48:59.181Z");
org.junit.Assert.assertNotNull(property42);
// flaky: org.junit.Assert.assertEquals("'" + str43 + "' != '" + "2020-11-25T01:48:59.181Z" + "'", str43, "2020-11-25T01:48:59.181Z");
org.junit.Assert.assertTrue("'" + int44 + "' != '" + (-1) + "'", int44 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime45);
// flaky: org.junit.Assert.assertEquals("'" + str50 + "' != '" + "2020-11-25T01:48:59.181Z" + "'", str50, "2020-11-25T01:48:59.181Z");
org.junit.Assert.assertTrue("'" + int51 + "' != '" + 20 + "'", int51 == 20);
org.junit.Assert.assertNotNull(chronology52);
org.junit.Assert.assertNotNull(mutableDateTime53);
org.junit.Assert.assertNotNull(mutableDateTime54);
org.junit.Assert.assertNotNull(dateTime55);
}
@Test
@Ignore
public void test1519() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1519");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.Date date4 = mutableDateTime2.toDate();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.centuryOfEra();
java.util.Locale locale6 = null;
java.lang.String str7 = property5.getAsShortText(locale6);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(date4);
org.junit.Assert.assertEquals(date4.toString(), "Thu Jan 01 00:00:00 UTC 1970");
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "19" + "'", str7, "19");
}
@Test
@Ignore
public void test1520() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1520");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime6.dayOfMonth();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime6.dayOfMonth();
mutableDateTime6.setTime((long) 10);
long long11 = property5.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime6);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + long11 + "' != '" + (-610L) + "'", long11 == (-610L));
}
@Test
@Ignore
public void test1521() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1521");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
boolean boolean10 = property8.isLeap();
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime13 = property12.getMutableDateTime();
org.joda.time.DateTime dateTime14 = mutableDateTime13.toDateTimeISO();
int int15 = property8.getDifference((org.joda.time.ReadableInstant) dateTime14);
org.joda.time.MutableDateTime mutableDateTime16 = property8.roundHalfCeiling();
org.joda.time.MutableDateTime mutableDateTime17 = property8.roundCeiling();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
org.joda.time.ReadablePeriod readablePeriod23 = null;
mutableDateTime20.add(readablePeriod23);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime20.hourOfDay();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime20.dayOfWeek();
int int27 = property26.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime29 = property26.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime30 = property26.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod31 = null;
mutableDateTime30.add(readablePeriod31, 40);
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
org.joda.time.format.DateTimeFormatter dateTimeFormatter37 = null;
java.lang.String str38 = mutableDateTime36.toString(dateTimeFormatter37);
int int39 = mutableDateTime36.getYearOfCentury();
org.joda.time.Chronology chronology40 = mutableDateTime36.getChronology();
org.joda.time.MutableDateTime mutableDateTime41 = mutableDateTime30.toMutableDateTime(chronology40);
org.joda.time.MutableDateTime mutableDateTime42 = org.joda.time.MutableDateTime.now(chronology40);
org.joda.time.MutableDateTime.Property property43 = mutableDateTime42.dayOfYear();
java.lang.String str44 = property43.getAsString();
long long45 = property43.remainder();
org.joda.time.DurationField durationField46 = property43.getRangeDurationField();
java.util.Locale locale47 = null;
java.lang.String str48 = property43.getAsText(locale47);
org.joda.time.Chronology chronology50 = null;
org.joda.time.MutableDateTime mutableDateTime51 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology50);
org.joda.time.MutableDateTime.Property property52 = mutableDateTime51.dayOfYear();
mutableDateTime51.setMillis((long) 9);
int int55 = property43.getDifference((org.joda.time.ReadableInstant) mutableDateTime51);
org.joda.time.DateTimeField dateTimeField56 = property43.getField();
// The following exception was thrown during execution in test generation
try {
mutableDateTime17.setRounding(dateTimeField56, 56);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal rounding mode: 56");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.292Z" + "'", str4, "2020-11-25T01:48:59.292Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(dateTime14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:48:59.293Z" + "'", str22, "2020-11-25T01:48:59.293Z");
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 7 + "'", int27 == 7);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime30);
// flaky: org.junit.Assert.assertEquals("'" + str38 + "' != '" + "2020-11-25T01:48:59.293Z" + "'", str38, "2020-11-25T01:48:59.293Z");
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 20 + "'", int39 == 20);
org.junit.Assert.assertNotNull(chronology40);
org.junit.Assert.assertNotNull(mutableDateTime41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(property43);
org.junit.Assert.assertEquals("'" + str44 + "' != '" + "330" + "'", str44, "330");
// flaky: org.junit.Assert.assertTrue("'" + long45 + "' != '" + 6539293L + "'", long45 == 6539293L);
org.junit.Assert.assertNotNull(durationField46);
org.junit.Assert.assertEquals("'" + str48 + "' != '" + "330" + "'", str48, "330");
org.junit.Assert.assertNotNull(property52);
org.junit.Assert.assertTrue("'" + int55 + "' != '" + 18591 + "'", int55 == 18591);
org.junit.Assert.assertNotNull(dateTimeField56);
}
@Test
public void test1522() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1522");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((-50L));
org.joda.time.ReadableDuration readableDuration2 = null;
mutableDateTime1.add(readableDuration2, 20);
mutableDateTime1.addMillis((int) (byte) 100);
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime15 = mutableDateTime9.toMutableDateTimeISO();
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime18.add(readablePeriod21);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime18.centuryOfEra();
org.joda.time.DateTimeField dateTimeField24 = property23.getField();
int int25 = mutableDateTime9.get(dateTimeField24);
int int26 = mutableDateTime1.get(dateTimeField24);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:48:59.333Z" + "'", str11, "2020-11-25T01:48:59.333Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(mutableDateTime15);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:48:59.333Z" + "'", str20, "2020-11-25T01:48:59.333Z");
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertNotNull(dateTimeField24);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 20 + "'", int25 == 20);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 19 + "'", int26 == 19);
}
@Test
@Ignore
public void test1523() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1523");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) 100, chronology29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology29);
org.joda.time.MutableDateTime mutableDateTime34 = mutableDateTime33.toMutableDateTimeISO();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:48:59.386Z" + "'", str11, "2020-11-25T01:48:59.386Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:48:59.386Z" + "'", str27, "2020-11-25T01:48:59.386Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime34);
}
@Test
public void test1524() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1524");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
mutableDateTime2.setTime((int) (short) 10, (int) '#', 49, (int) (byte) 10);
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.Instant instant14 = mutableDateTime13.toInstant();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime13.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime16 = property15.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime16.toMutableDateTime();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime16.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime20 = property18.set(49);
org.joda.time.MutableDateTime mutableDateTime21 = property18.roundHalfFloor();
org.joda.time.DateTimeFieldType dateTimeFieldType22 = property18.getFieldType();
int int23 = property18.getMaximumValue();
org.joda.time.DateTimeFieldType dateTimeFieldType24 = property18.getFieldType();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime2.property(dateTimeFieldType24);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(instant14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(dateTimeFieldType22);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 99 + "'", int23 == 99);
org.junit.Assert.assertNotNull(dateTimeFieldType24);
org.junit.Assert.assertNotNull(property25);
}
@Test
@Ignore
public void test1525() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1525");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime2.add(readablePeriod7);
mutableDateTime2.setMonthOfYear((int) (byte) 1);
mutableDateTime2.setSecondOfDay(635);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.498Z" + "'", str4, "2020-11-25T01:48:59.498Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
}
@Test
@Ignore
public void test1526() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1526");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone4);
org.joda.time.DateTime dateTime6 = mutableDateTime5.toDateTimeISO();
java.util.Date date7 = mutableDateTime5.toDate();
boolean boolean9 = mutableDateTime5.isAfter((long) (byte) 10);
mutableDateTime5.addMinutes(19);
java.lang.Object obj13 = null;
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime(obj13, chronology14);
org.joda.time.DateTimeZone dateTimeZone16 = mutableDateTime15.getZone();
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone16);
org.joda.time.DateTime dateTime18 = mutableDateTime5.toDateTime(dateTimeZone16);
int int19 = mutableDateTime5.getHourOfDay();
org.junit.Assert.assertNotNull(dateTimeZone4);
org.junit.Assert.assertNotNull(dateTime6);
org.junit.Assert.assertNotNull(date7);
org.junit.Assert.assertEquals(date7.toString(), "Wed Nov 25 01:44:41 UTC 2020");
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + true + "'", boolean9 == true);
org.junit.Assert.assertNotNull(dateTimeZone16);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 2 + "'", int19 == 2);
}
@Test
public void test1527() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1527");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
mutableDateTime2.setMillisOfDay(0);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime2.year();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.548Z" + "'", str4, "2020-11-25T01:48:59.548Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:48:59.548Z" + "'", str11, "2020-11-25T01:48:59.548Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:48:59.548Z" + "'", str15, "2020-11-25T01:48:59.548Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(property21);
}
@Test
public void test1528() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1528");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = property3.roundCeiling();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime4.minuteOfHour();
int int6 = mutableDateTime4.getYearOfEra();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.centuryOfEra();
org.joda.time.DateTimeField dateTimeField15 = property14.getField();
boolean boolean16 = mutableDateTime4.equals((java.lang.Object) property14);
long long17 = property14.remainder();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1970 + "'", int6 == 1970);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:48:59.581Z" + "'", str11, "2020-11-25T01:48:59.581Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(dateTimeField15);
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// flaky: org.junit.Assert.assertTrue("'" + long17 + "' != '" + (-1549491060419L) + "'", long17 == (-1549491060419L));
}
@Test
@Ignore
public void test1529() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1529");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime11 = property9.add((long) 48);
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.format.DateTimeFormatter dateTimeFormatter15 = null;
java.lang.String str16 = mutableDateTime14.toString(dateTimeFormatter15);
org.joda.time.ReadablePeriod readablePeriod17 = null;
mutableDateTime14.add(readablePeriod17);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime14.yearOfCentury();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime14.dayOfWeek();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime14.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime22 = property21.roundCeiling();
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
mutableDateTime25.setTime((long) '#');
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
org.joda.time.ReadablePeriod readablePeriod35 = null;
mutableDateTime32.add(readablePeriod35);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime32.hourOfDay();
java.lang.String str38 = mutableDateTime32.toString();
int int39 = mutableDateTime25.compareTo((org.joda.time.ReadableInstant) mutableDateTime32);
org.joda.time.MutableDateTime mutableDateTime40 = mutableDateTime25.copy();
java.lang.Object obj41 = null;
org.joda.time.Chronology chronology42 = null;
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime(obj41, chronology42);
org.joda.time.format.DateTimeFormatter dateTimeFormatter44 = null;
java.lang.String str45 = mutableDateTime43.toString(dateTimeFormatter44);
int int46 = mutableDateTime43.getYearOfCentury();
org.joda.time.Chronology chronology47 = mutableDateTime43.getChronology();
int int48 = mutableDateTime43.getWeekOfWeekyear();
java.lang.Object obj49 = null;
org.joda.time.Chronology chronology50 = null;
org.joda.time.MutableDateTime mutableDateTime51 = new org.joda.time.MutableDateTime(obj49, chronology50);
org.joda.time.DateTimeZone dateTimeZone52 = mutableDateTime51.getZone();
org.joda.time.DateTime dateTime53 = mutableDateTime43.toDateTime(dateTimeZone52);
org.joda.time.DateTimeZone dateTimeZone54 = mutableDateTime43.getZone();
mutableDateTime40.setZoneRetainFields(dateTimeZone54);
org.joda.time.MutableDateTime mutableDateTime56 = mutableDateTime22.toMutableDateTime(dateTimeZone54);
mutableDateTime11.setZoneRetainFields(dateTimeZone54);
mutableDateTime11.add((long) 14);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.607Z" + "'", str4, "2020-11-25T01:48:59.607Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(mutableDateTime11);
// flaky: org.junit.Assert.assertEquals("'" + str16 + "' != '" + "2020-11-25T01:48:59.607Z" + "'", str16, "2020-11-25T01:48:59.607Z");
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:48:59.607Z" + "'", str27, "2020-11-25T01:48:59.607Z");
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:48:59.607Z" + "'", str34, "2020-11-25T01:48:59.607Z");
org.junit.Assert.assertNotNull(property37);
// flaky: org.junit.Assert.assertEquals("'" + str38 + "' != '" + "2020-11-25T01:48:59.607Z" + "'", str38, "2020-11-25T01:48:59.607Z");
org.junit.Assert.assertTrue("'" + int39 + "' != '" + (-1) + "'", int39 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime40);
// flaky: org.junit.Assert.assertEquals("'" + str45 + "' != '" + "2020-11-25T01:48:59.607Z" + "'", str45, "2020-11-25T01:48:59.607Z");
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 20 + "'", int46 == 20);
org.junit.Assert.assertNotNull(chronology47);
org.junit.Assert.assertTrue("'" + int48 + "' != '" + 48 + "'", int48 == 48);
org.junit.Assert.assertNotNull(dateTimeZone52);
org.junit.Assert.assertNotNull(dateTime53);
org.junit.Assert.assertNotNull(dateTimeZone54);
org.junit.Assert.assertNotNull(mutableDateTime56);
}
@Test
@Ignore
public void test1530() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1530");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.DateTimeField dateTimeField4 = property2.getField();
java.util.Locale locale5 = null;
int int6 = property2.getMaximumTextLength(locale5);
java.util.Locale locale7 = null;
int int8 = property2.getMaximumTextLength(locale7);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField4);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 9 + "'", int6 == 9);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 9 + "'", int8 == 9);
}
@Test
public void test1531() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1531");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.secondOfMinute();
int int8 = property7.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfEven();
org.joda.time.DateTime dateTime10 = mutableDateTime9.toDateTimeISO();
int int11 = dateTime10.getYear();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 59 + "'", int8 == 59);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(dateTime10);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 2021 + "'", int11 == 2021);
}
@Test
public void test1532() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1532");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.minuteOfHour();
int int14 = mutableDateTime12.getSecondOfMinute();
org.joda.time.MutableDateTime mutableDateTime15 = mutableDateTime12.copy();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.733Z" + "'", str4, "2020-11-25T01:48:59.733Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
org.junit.Assert.assertNotNull(mutableDateTime15);
}
@Test
@Ignore
public void test1533() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1533");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
mutableDateTime13.addDays(2189);
int int17 = mutableDateTime13.getSecondOfMinute();
int int18 = mutableDateTime13.getMinuteOfHour();
int int19 = mutableDateTime13.getDayOfWeek();
mutableDateTime13.setDate(1580521636005L);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.763Z" + "'", str4, "2020-11-25T01:48:59.763Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
// flaky: org.junit.Assert.assertTrue("'" + int17 + "' != '" + 59 + "'", int17 == 59);
// flaky: org.junit.Assert.assertTrue("'" + int18 + "' != '" + 48 + "'", int18 == 48);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 1 + "'", int19 == 1);
}
@Test
public void test1534() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1534");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.Instant instant4 = mutableDateTime3.toInstant();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime3.monthOfYear();
mutableDateTime3.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.secondOfMinute();
int int9 = property8.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime10 = property8.roundHalfEven();
org.joda.time.Chronology chronology11 = mutableDateTime10.getChronology();
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime((java.lang.Object) 1.0d, chronology11);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: No instant converter found for type: java.lang.Double");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 59 + "'", int9 == 59);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(chronology11);
}
@Test
@Ignore
public void test1535() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1535");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
mutableDateTime2.setWeekyear(422);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime2.year();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.929Z" + "'", str4, "2020-11-25T01:48:59.929Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property16);
}
@Test
@Ignore
public void test1536() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1536");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
boolean boolean24 = mutableDateTime23.isBeforeNow();
int int25 = mutableDateTime23.getWeekOfWeekyear();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime23.dayOfMonth();
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = mutableDateTime23.toMutableDateTime(chronology27);
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.format.DateTimeFormatter dateTimeFormatter32 = null;
java.lang.String str33 = mutableDateTime31.toString(dateTimeFormatter32);
org.joda.time.ReadablePeriod readablePeriod34 = null;
mutableDateTime31.add(readablePeriod34);
org.joda.time.MutableDateTime.Property property36 = mutableDateTime31.hourOfDay();
org.joda.time.MutableDateTime.Property property37 = mutableDateTime31.dayOfWeek();
org.joda.time.DurationField durationField38 = property37.getRangeDurationField();
boolean boolean39 = property37.isLeap();
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property41 = mutableDateTime40.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime42 = property41.getMutableDateTime();
org.joda.time.DateTime dateTime43 = mutableDateTime42.toDateTimeISO();
int int44 = property37.getDifference((org.joda.time.ReadableInstant) dateTime43);
org.joda.time.MutableDateTime mutableDateTime45 = property37.roundHalfCeiling();
org.joda.time.DurationField durationField46 = property37.getLeapDurationField();
boolean boolean47 = mutableDateTime23.equals((java.lang.Object) property37);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:48:59.963Z" + "'", str4, "2020-11-25T01:48:59.963Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:48:59.963Z" + "'", str20, "2020-11-25T01:48:59.963Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + true + "'", boolean24 == true);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 48 + "'", int25 == 48);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(mutableDateTime28);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:48:59.963Z" + "'", str33, "2020-11-25T01:48:59.963Z");
org.junit.Assert.assertNotNull(property36);
org.junit.Assert.assertNotNull(property37);
org.junit.Assert.assertNotNull(durationField38);
org.junit.Assert.assertTrue("'" + boolean39 + "' != '" + false + "'", boolean39 == false);
org.junit.Assert.assertNotNull(property41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime43);
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 0 + "'", int44 == 0);
org.junit.Assert.assertNotNull(mutableDateTime45);
org.junit.Assert.assertNull(durationField46);
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
}
@Test
@Ignore
public void test1537() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1537");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
mutableDateTime3.setTime((long) '#');
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
java.lang.String str16 = mutableDateTime10.toString();
int int17 = mutableDateTime3.compareTo((org.joda.time.ReadableInstant) mutableDateTime10);
mutableDateTime10.addDays(19);
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime20.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime22 = property21.getMutableDateTime();
org.joda.time.DateTimeZone dateTimeZone23 = mutableDateTime22.getZone();
mutableDateTime10.setZone(dateTimeZone23);
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology26);
org.joda.time.MutableDateTime.Property property28 = mutableDateTime27.dayOfYear();
java.util.GregorianCalendar gregorianCalendar29 = mutableDateTime27.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property30 = mutableDateTime27.monthOfYear();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.format.DateTimeFormatter dateTimeFormatter35 = null;
java.lang.String str36 = mutableDateTime34.toString(dateTimeFormatter35);
org.joda.time.ReadablePeriod readablePeriod37 = null;
mutableDateTime34.add(readablePeriod37);
org.joda.time.MutableDateTime.Property property39 = mutableDateTime34.hourOfDay();
org.joda.time.MutableDateTime.Property property40 = mutableDateTime34.dayOfWeek();
int int41 = property40.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime43 = property40.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime44 = property40.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod45 = null;
mutableDateTime44.add(readablePeriod45, 40);
java.lang.Object obj48 = null;
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime(obj48, chronology49);
org.joda.time.format.DateTimeFormatter dateTimeFormatter51 = null;
java.lang.String str52 = mutableDateTime50.toString(dateTimeFormatter51);
int int53 = mutableDateTime50.getYearOfCentury();
org.joda.time.Chronology chronology54 = mutableDateTime50.getChronology();
org.joda.time.MutableDateTime mutableDateTime55 = mutableDateTime44.toMutableDateTime(chronology54);
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime((long) 100, chronology54);
org.joda.time.MutableDateTime mutableDateTime57 = new org.joda.time.MutableDateTime(chronology54);
org.joda.time.MutableDateTime mutableDateTime58 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime27, chronology54);
org.joda.time.MutableDateTime mutableDateTime59 = new org.joda.time.MutableDateTime(chronology54);
org.joda.time.MutableDateTime mutableDateTime60 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime10, chronology54);
org.joda.time.MutableDateTime mutableDateTime61 = new org.joda.time.MutableDateTime((long) 6351, chronology54);
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:00.012Z" + "'", str5, "2020-11-25T01:49:00.012Z");
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:00.012Z" + "'", str12, "2020-11-25T01:49:00.012Z");
org.junit.Assert.assertNotNull(property15);
// flaky: org.junit.Assert.assertEquals("'" + str16 + "' != '" + "2020-11-25T01:49:00.012Z" + "'", str16, "2020-11-25T01:49:00.012Z");
org.junit.Assert.assertTrue("'" + int17 + "' != '" + (-1) + "'", int17 == (-1));
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(dateTimeZone23);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertNotNull(gregorianCalendar29);
org.junit.Assert.assertNotNull(property30);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:00.012Z" + "'", str36, "2020-11-25T01:49:00.012Z");
org.junit.Assert.assertNotNull(property39);
org.junit.Assert.assertNotNull(property40);
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 7 + "'", int41 == 7);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(mutableDateTime44);
// flaky: org.junit.Assert.assertEquals("'" + str52 + "' != '" + "2020-11-25T01:49:00.012Z" + "'", str52, "2020-11-25T01:49:00.012Z");
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 20 + "'", int53 == 20);
org.junit.Assert.assertNotNull(chronology54);
org.junit.Assert.assertNotNull(mutableDateTime55);
}
@Test
@Ignore
public void test1538() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1538");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundHalfEven();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.hourOfDay();
org.joda.time.MutableDateTime.Property property17 = mutableDateTime11.dayOfWeek();
int int18 = property17.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime20 = property17.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime21 = property17.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime21.add(readablePeriod22, 40);
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.format.DateTimeFormatter dateTimeFormatter28 = null;
java.lang.String str29 = mutableDateTime27.toString(dateTimeFormatter28);
int int30 = mutableDateTime27.getYearOfCentury();
org.joda.time.Chronology chronology31 = mutableDateTime27.getChronology();
org.joda.time.MutableDateTime mutableDateTime32 = mutableDateTime21.toMutableDateTime(chronology31);
org.joda.time.MutableDateTime mutableDateTime33 = org.joda.time.MutableDateTime.now(chronology31);
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
org.joda.time.format.DateTimeFormatter dateTimeFormatter37 = null;
java.lang.String str38 = mutableDateTime36.toString(dateTimeFormatter37);
org.joda.time.ReadablePeriod readablePeriod39 = null;
mutableDateTime36.add(readablePeriod39);
org.joda.time.MutableDateTime.Property property41 = mutableDateTime36.hourOfDay();
org.joda.time.MutableDateTime.Property property42 = mutableDateTime36.dayOfWeek();
org.joda.time.DurationField durationField43 = property42.getRangeDurationField();
org.joda.time.DurationField durationField44 = property42.getDurationField();
org.joda.time.DateTimeField dateTimeField45 = property42.getField();
mutableDateTime33.setRounding(dateTimeField45);
boolean boolean47 = mutableDateTime8.equals((java.lang.Object) dateTimeField45);
org.joda.time.MutableDateTime.Property property48 = mutableDateTime8.millisOfSecond();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.101Z" + "'", str4, "2020-11-25T01:49:00.101Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:00.101Z" + "'", str13, "2020-11-25T01:49:00.101Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 7 + "'", int18 == 7);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertNotNull(mutableDateTime21);
// flaky: org.junit.Assert.assertEquals("'" + str29 + "' != '" + "2020-11-25T01:49:00.101Z" + "'", str29, "2020-11-25T01:49:00.101Z");
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 20 + "'", int30 == 20);
org.junit.Assert.assertNotNull(chronology31);
org.junit.Assert.assertNotNull(mutableDateTime32);
org.junit.Assert.assertNotNull(mutableDateTime33);
// flaky: org.junit.Assert.assertEquals("'" + str38 + "' != '" + "2020-11-25T01:49:00.101Z" + "'", str38, "2020-11-25T01:49:00.101Z");
org.junit.Assert.assertNotNull(property41);
org.junit.Assert.assertNotNull(property42);
org.junit.Assert.assertNotNull(durationField43);
org.junit.Assert.assertNotNull(durationField44);
org.junit.Assert.assertNotNull(dateTimeField45);
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
org.junit.Assert.assertNotNull(property48);
}
@Test
public void test1539() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1539");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
java.lang.Class<?> wildcardClass7 = mutableDateTime2.getClass();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.148Z" + "'", str4, "2020-11-25T01:49:00.148Z");
org.junit.Assert.assertNotNull(wildcardClass7);
}
@Test
@Ignore
public void test1540() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1540");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
mutableDateTime6.setMillis((long) (-1));
int int9 = mutableDateTime6.getDayOfYear();
int int10 = mutableDateTime6.getDayOfYear();
org.joda.time.ReadablePeriod readablePeriod11 = null;
mutableDateTime6.add(readablePeriod11);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime6.yearOfEra();
mutableDateTime6.setMinuteOfDay(0);
org.joda.time.DateTime dateTime16 = mutableDateTime6.toDateTime();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 365 + "'", int9 == 365);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 365 + "'", int10 == 365);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(dateTime16);
}
@Test
@Ignore
public void test1541() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1541");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
int int8 = property7.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
org.joda.time.DurationField durationField10 = property7.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime11 = property7.roundHalfFloor();
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology13);
mutableDateTime14.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property17 = mutableDateTime14.minuteOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime14.year();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.hourOfDay();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
int int28 = property27.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime30 = property27.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime31 = property27.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod32 = null;
mutableDateTime31.add(readablePeriod32, 40);
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
int int40 = mutableDateTime37.getYearOfCentury();
org.joda.time.Chronology chronology41 = mutableDateTime37.getChronology();
org.joda.time.MutableDateTime mutableDateTime42 = mutableDateTime31.toMutableDateTime(chronology41);
mutableDateTime14.setChronology(chronology41);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(chronology41);
org.joda.time.DateTime dateTime45 = mutableDateTime11.toDateTime(chronology41);
int int46 = mutableDateTime11.getWeekyear();
org.joda.time.MutableDateTime.Property property47 = mutableDateTime11.era();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.206Z" + "'", str4, "2020-11-25T01:49:00.206Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:00.206Z" + "'", str23, "2020-11-25T01:49:00.206Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 7 + "'", int28 == 7);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime31);
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:00.206Z" + "'", str39, "2020-11-25T01:49:00.206Z");
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 20 + "'", int40 == 20);
org.junit.Assert.assertNotNull(chronology41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime45);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 2020 + "'", int46 == 2020);
org.junit.Assert.assertNotNull(property47);
}
@Test
public void test1542() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1542");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
int int8 = property7.get();
org.joda.time.MutableDateTime mutableDateTime10 = property7.addWrapField(6300);
org.joda.time.MutableDateTime mutableDateTime11 = property7.roundHalfCeiling();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.251Z" + "'", str4, "2020-11-25T01:49:00.251Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
@Test
@Ignore
public void test1543() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1543");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
mutableDateTime2.add((long) 3);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.monthOfYear();
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime2.toString(dateTimeFormatter13);
int int15 = mutableDateTime2.getWeekyear();
java.lang.Object obj16 = mutableDateTime2.clone();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.285Z" + "'", str4, "2020-11-25T01:49:00.285Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property12);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:00.288Z" + "'", str14, "2020-11-25T01:49:00.288Z");
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 2020 + "'", int15 == 2020);
org.junit.Assert.assertNotNull(obj16);
// flaky: org.junit.Assert.assertEquals(obj16.toString(), "2020-11-25T01:49:00.288Z");
// flaky: org.junit.Assert.assertEquals(java.lang.String.valueOf(obj16), "2020-11-25T01:49:00.288Z");
// flaky: org.junit.Assert.assertEquals(java.util.Objects.toString(obj16), "2020-11-25T01:49:00.288Z");
}
@Test
public void test1544() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1544");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
org.joda.time.MutableDateTime mutableDateTime10 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.minuteOfDay();
org.joda.time.MutableDateTime mutableDateTime12 = mutableDateTime10.copy();
mutableDateTime10.setWeekyear(6319);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.era();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property15);
}
@Test
@Ignore
public void test1545() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1545");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.Instant instant14 = mutableDateTime13.toInstant();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime13.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime16 = property15.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime16.toMutableDateTime();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime16.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime19 = property18.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime19.copy();
boolean boolean21 = mutableDateTime2.isBefore((org.joda.time.ReadableInstant) mutableDateTime19);
org.joda.time.MutableDateTime.Property property22 = mutableDateTime19.centuryOfEra();
long long23 = mutableDateTime19.getMillis();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.338Z" + "'", str4, "2020-11-25T01:49:00.338Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(instant14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + long23 + "' != '" + 1609459200000L + "'", long23 == 1609459200000L);
}
@Test
@Ignore
public void test1546() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1546");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.Instant instant12 = mutableDateTime11.toInstant();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime11.monthOfYear();
mutableDateTime11.setMonthOfYear((int) (byte) 10);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.yearOfCentury();
mutableDateTime8.setTime((org.joda.time.ReadableInstant) mutableDateTime11);
java.util.Date date18 = mutableDateTime11.toDate();
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime11.copy();
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime11.getZone();
int int21 = mutableDateTime11.getCenturyOfEra();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(instant12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(date18);
// flaky: org.junit.Assert.assertEquals(date18.toString(), "Sun Oct 25 01:49:00 UTC 2020");
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
}
@Test
@Ignore
public void test1547() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1547");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
mutableDateTime5.addHours(59);
java.lang.Object obj9 = mutableDateTime5.clone();
int int10 = mutableDateTime5.getRoundingMode();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(obj9);
org.junit.Assert.assertEquals(obj9.toString(), "2020-12-03T11:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj9), "2020-12-03T11:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj9), "2020-12-03T11:00:00.000Z");
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 0 + "'", int10 == 0);
}
@Test
public void test1548() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1548");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
mutableDateTime2.setMinuteOfDay(4);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.monthOfYear();
int int8 = mutableDateTime2.getMillisOfSecond();
org.junit.Assert.assertNotNull(dateTimeZone3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertTrue("'" + int8 + "' != '" + 470 + "'", int8 == 470);
}
@Test
public void test1549() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1549");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
boolean boolean10 = mutableDateTime9.isEqualNow();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime9.dayOfMonth();
int int12 = mutableDateTime9.getYearOfCentury();
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime9);
boolean boolean15 = mutableDateTime13.isEqual((long) (-1));
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 49 + "'", int12 == 49);
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
}
@Test
@Ignore
public void test1550() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1550");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
int int33 = property2.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime34 = property2.roundHalfFloor();
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
org.joda.time.ReadablePeriod readablePeriod40 = null;
mutableDateTime37.add(readablePeriod40);
org.joda.time.MutableDateTime.Property property42 = mutableDateTime37.hourOfDay();
org.joda.time.MutableDateTime.Property property43 = mutableDateTime37.dayOfWeek();
int int44 = property43.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime46 = property43.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime47 = property43.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod48 = null;
mutableDateTime47.add(readablePeriod48, 40);
mutableDateTime47.setMinuteOfHour(1);
int int53 = mutableDateTime34.compareTo((org.joda.time.ReadableInstant) mutableDateTime47);
int int54 = mutableDateTime47.getMillisOfDay();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:00.524Z" + "'", str13, "2020-11-25T01:49:00.524Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:00.524Z" + "'", str27, "2020-11-25T01:49:00.524Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 1 + "'", int33 == 1);
org.junit.Assert.assertNotNull(mutableDateTime34);
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:00.524Z" + "'", str39, "2020-11-25T01:49:00.524Z");
org.junit.Assert.assertNotNull(property42);
org.junit.Assert.assertNotNull(property43);
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 7 + "'", int44 == 7);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertTrue("'" + int53 + "' != '" + (-1) + "'", int53 == (-1));
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 60000 + "'", int54 == 60000);
}
@Test
@Ignore
public void test1551() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1551");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = property3.roundCeiling();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime4.minuteOfHour();
org.joda.time.DateTimeField dateTimeField6 = property5.getField();
int int7 = property5.getMinimumValue();
org.joda.time.MutableDateTime mutableDateTime8 = property5.getMutableDateTime();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
org.joda.time.ReadableInstant readableInstant17 = null;
mutableDateTime11.setDate(readableInstant17);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime19.dayOfMonth();
int int21 = mutableDateTime19.getCenturyOfEra();
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology23);
mutableDateTime24.setSecondOfMinute((int) '4');
int int27 = mutableDateTime24.getMinuteOfDay();
int int28 = mutableDateTime24.getCenturyOfEra();
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
int int32 = mutableDateTime31.getDayOfWeek();
java.lang.Object obj33 = null;
org.joda.time.Chronology chronology34 = null;
org.joda.time.MutableDateTime mutableDateTime35 = new org.joda.time.MutableDateTime(obj33, chronology34);
org.joda.time.DateTimeZone dateTimeZone36 = mutableDateTime35.getZone();
org.joda.time.MutableDateTime mutableDateTime37 = org.joda.time.MutableDateTime.now(dateTimeZone36);
mutableDateTime31.setZoneRetainFields(dateTimeZone36);
org.joda.time.DateTime dateTime39 = mutableDateTime24.toDateTime(dateTimeZone36);
mutableDateTime19.setZoneRetainFields(dateTimeZone36);
mutableDateTime11.setZone(dateTimeZone36);
org.joda.time.MutableDateTime mutableDateTime42 = org.joda.time.MutableDateTime.now(dateTimeZone36);
mutableDateTime8.setZoneRetainFields(dateTimeZone36);
int int44 = mutableDateTime8.getYearOfCentury();
boolean boolean45 = mutableDateTime8.isAfterNow();
int int46 = mutableDateTime8.getYearOfEra();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(dateTimeField6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
org.junit.Assert.assertNotNull(mutableDateTime8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:00.561Z" + "'", str13, "2020-11-25T01:49:00.561Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 0 + "'", int27 == 0);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 19 + "'", int28 == 19);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 3 + "'", int32 == 3);
org.junit.Assert.assertNotNull(dateTimeZone36);
org.junit.Assert.assertNotNull(mutableDateTime37);
org.junit.Assert.assertNotNull(dateTime39);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 70 + "'", int44 == 70);
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + false + "'", boolean45 == false);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 1970 + "'", int46 == 1970);
}
@Test
@Ignore
public void test1552() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1552");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.setMonthOfYear((int) (byte) 10);
mutableDateTime2.addWeeks((int) (short) 10);
int int9 = mutableDateTime2.getDayOfMonth();
mutableDateTime2.add((long) (-292275054));
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime2.add(readablePeriod12);
int int14 = mutableDateTime2.getDayOfMonth();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 3 + "'", int9 == 3);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 30 + "'", int14 == 30);
}
@Test
@Ignore
public void test1553() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1553");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
org.joda.time.ReadableDuration readableDuration9 = null;
mutableDateTime2.add(readableDuration9, 422);
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology14);
mutableDateTime15.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property18 = mutableDateTime15.minuteOfDay();
org.joda.time.MutableDateTime.Property property19 = mutableDateTime15.year();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
org.joda.time.ReadablePeriod readablePeriod25 = null;
mutableDateTime22.add(readablePeriod25);
org.joda.time.MutableDateTime.Property property27 = mutableDateTime22.hourOfDay();
org.joda.time.MutableDateTime.Property property28 = mutableDateTime22.dayOfWeek();
int int29 = property28.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime31 = property28.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime32 = property28.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime32.add(readablePeriod33, 40);
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
int int41 = mutableDateTime38.getYearOfCentury();
org.joda.time.Chronology chronology42 = mutableDateTime38.getChronology();
org.joda.time.MutableDateTime mutableDateTime43 = mutableDateTime32.toMutableDateTime(chronology42);
mutableDateTime15.setChronology(chronology42);
org.joda.time.MutableDateTime mutableDateTime45 = new org.joda.time.MutableDateTime(chronology42);
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime(obj12, chronology42);
org.joda.time.DateTime dateTime47 = mutableDateTime2.toDateTime(chronology42);
org.joda.time.MutableDateTime mutableDateTime48 = org.joda.time.MutableDateTime.now(chronology42);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(property19);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:00.678Z" + "'", str24, "2020-11-25T01:49:00.678Z");
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 7 + "'", int29 == 7);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime32);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:00.678Z" + "'", str40, "2020-11-25T01:49:00.678Z");
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 20 + "'", int41 == 20);
org.junit.Assert.assertNotNull(chronology42);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(dateTime47);
org.junit.Assert.assertNotNull(mutableDateTime48);
}
@Test
@Ignore
public void test1554() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1554");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.Interval interval4 = property2.toInterval();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.format.DateTimeFormatter dateTimeFormatter8 = null;
java.lang.String str9 = mutableDateTime7.toString(dateTimeFormatter8);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime7.add(readablePeriod10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime7.centuryOfEra();
boolean boolean13 = property2.equals((java.lang.Object) mutableDateTime7);
mutableDateTime7.setTime((long) ' ');
int int16 = mutableDateTime7.getSecondOfMinute();
org.joda.time.DateTimeZone dateTimeZone17 = null;
mutableDateTime7.setZoneRetainFields(dateTimeZone17);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(interval4);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:00.726Z" + "'", str9, "2020-11-25T01:49:00.726Z");
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 0 + "'", int16 == 0);
}
@Test
@Ignore
public void test1555() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1555");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
int int8 = mutableDateTime7.getCenturyOfEra();
int int9 = mutableDateTime7.getDayOfYear();
mutableDateTime7.setDate((long) 7);
mutableDateTime7.setMinuteOfDay(29);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.766Z" + "'", str4, "2020-11-25T01:49:00.766Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 330 + "'", int9 == 330);
}
@Test
@Ignore
public void test1556() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1556");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
int int3 = mutableDateTime0.getRoundingMode();
java.lang.Object obj4 = null;
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime(obj4, chronology5);
org.joda.time.DateTimeZone dateTimeZone7 = mutableDateTime6.getZone();
int int8 = mutableDateTime6.getSecondOfMinute();
int int9 = mutableDateTime6.getMonthOfYear();
org.joda.time.Chronology chronology10 = mutableDateTime6.getChronology();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
org.joda.time.ReadablePeriod readablePeriod16 = null;
mutableDateTime13.add(readablePeriod16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.centuryOfEra();
org.joda.time.ReadableInstant readableInstant19 = null;
mutableDateTime13.setDate(readableInstant19);
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime21.dayOfMonth();
int int23 = mutableDateTime21.getCenturyOfEra();
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology25);
mutableDateTime26.setSecondOfMinute((int) '4');
int int29 = mutableDateTime26.getMinuteOfDay();
int int30 = mutableDateTime26.getCenturyOfEra();
java.lang.Object obj31 = null;
org.joda.time.Chronology chronology32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(obj31, chronology32);
int int34 = mutableDateTime33.getDayOfWeek();
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.DateTimeZone dateTimeZone38 = mutableDateTime37.getZone();
org.joda.time.MutableDateTime mutableDateTime39 = org.joda.time.MutableDateTime.now(dateTimeZone38);
mutableDateTime33.setZoneRetainFields(dateTimeZone38);
org.joda.time.DateTime dateTime41 = mutableDateTime26.toDateTime(dateTimeZone38);
mutableDateTime21.setZoneRetainFields(dateTimeZone38);
mutableDateTime13.setZone(dateTimeZone38);
org.joda.time.MutableDateTime mutableDateTime44 = org.joda.time.MutableDateTime.now(dateTimeZone38);
org.joda.time.MutableDateTime mutableDateTime45 = mutableDateTime6.toMutableDateTime(dateTimeZone38);
org.joda.time.MutableDateTime mutableDateTime46 = mutableDateTime0.toMutableDateTime(dateTimeZone38);
int int47 = mutableDateTime46.getDayOfWeek();
java.lang.Object obj48 = null;
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime(obj48, chronology49);
org.joda.time.DateTimeZone dateTimeZone51 = mutableDateTime50.getZone();
mutableDateTime50.setMinuteOfDay(4);
java.lang.Object obj54 = null;
org.joda.time.Chronology chronology55 = null;
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime(obj54, chronology55);
org.joda.time.format.DateTimeFormatter dateTimeFormatter57 = null;
java.lang.String str58 = mutableDateTime56.toString(dateTimeFormatter57);
int int59 = mutableDateTime56.getYearOfCentury();
org.joda.time.Chronology chronology60 = mutableDateTime56.getChronology();
int int61 = mutableDateTime56.getWeekOfWeekyear();
java.lang.Object obj62 = null;
org.joda.time.Chronology chronology63 = null;
org.joda.time.MutableDateTime mutableDateTime64 = new org.joda.time.MutableDateTime(obj62, chronology63);
org.joda.time.DateTimeZone dateTimeZone65 = mutableDateTime64.getZone();
org.joda.time.DateTime dateTime66 = mutableDateTime56.toDateTime(dateTimeZone65);
org.joda.time.MutableDateTime mutableDateTime67 = mutableDateTime50.toMutableDateTime(dateTimeZone65);
org.joda.time.MutableDateTime mutableDateTime68 = new org.joda.time.MutableDateTime(dateTimeZone65);
java.lang.Object obj69 = mutableDateTime68.clone();
int int70 = mutableDateTime68.getHourOfDay();
mutableDateTime68.addWeeks(6423656);
mutableDateTime46.setMillis((org.joda.time.ReadableInstant) mutableDateTime68);
org.joda.time.Chronology chronology75 = null;
org.joda.time.MutableDateTime mutableDateTime76 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology75);
org.joda.time.MutableDateTime.Property property77 = mutableDateTime76.dayOfYear();
mutableDateTime76.setMillis((long) 9);
org.joda.time.MutableDateTime.Property property80 = mutableDateTime76.dayOfMonth();
org.joda.time.DateTimeField dateTimeField81 = property80.getField();
int int82 = mutableDateTime46.get(dateTimeField81);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertNotNull(dateTimeZone7);
// flaky: org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 11 + "'", int9 == 11);
org.junit.Assert.assertNotNull(chronology10);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:00.802Z" + "'", str15, "2020-11-25T01:49:00.802Z");
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 0 + "'", int29 == 0);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 19 + "'", int30 == 19);
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 3 + "'", int34 == 3);
org.junit.Assert.assertNotNull(dateTimeZone38);
org.junit.Assert.assertNotNull(mutableDateTime39);
org.junit.Assert.assertNotNull(dateTime41);
org.junit.Assert.assertNotNull(mutableDateTime44);
org.junit.Assert.assertNotNull(mutableDateTime45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertTrue("'" + int47 + "' != '" + 3 + "'", int47 == 3);
org.junit.Assert.assertNotNull(dateTimeZone51);
// flaky: org.junit.Assert.assertEquals("'" + str58 + "' != '" + "2020-11-25T01:49:00.802Z" + "'", str58, "2020-11-25T01:49:00.802Z");
org.junit.Assert.assertTrue("'" + int59 + "' != '" + 20 + "'", int59 == 20);
org.junit.Assert.assertNotNull(chronology60);
org.junit.Assert.assertTrue("'" + int61 + "' != '" + 48 + "'", int61 == 48);
org.junit.Assert.assertNotNull(dateTimeZone65);
org.junit.Assert.assertNotNull(dateTime66);
org.junit.Assert.assertNotNull(mutableDateTime67);
org.junit.Assert.assertNotNull(obj69);
// flaky: org.junit.Assert.assertEquals(obj69.toString(), "2020-11-25T01:49:00.802Z");
// flaky: org.junit.Assert.assertEquals(java.lang.String.valueOf(obj69), "2020-11-25T01:49:00.802Z");
// flaky: org.junit.Assert.assertEquals(java.util.Objects.toString(obj69), "2020-11-25T01:49:00.802Z");
org.junit.Assert.assertTrue("'" + int70 + "' != '" + 1 + "'", int70 == 1);
org.junit.Assert.assertNotNull(property77);
org.junit.Assert.assertNotNull(property80);
org.junit.Assert.assertNotNull(dateTimeField81);
org.junit.Assert.assertTrue("'" + int82 + "' != '" + 6 + "'", int82 == 6);
}
@Test
@Ignore
public void test1557() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1557");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
mutableDateTime13.addDays(2189);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.year();
mutableDateTime13.setMillisOfDay(60000);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.890Z" + "'", str4, "2020-11-25T01:49:00.890Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
org.junit.Assert.assertNotNull(property17);
}
@Test
public void test1558() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1558");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
int int8 = property7.get();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfEven();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.centuryOfEra();
int int18 = property17.get();
org.joda.time.MutableDateTime mutableDateTime19 = property17.roundHalfEven();
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology21);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime24 = property23.roundCeiling();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.minuteOfHour();
org.joda.time.DateTimeField dateTimeField26 = property25.getField();
int int27 = mutableDateTime19.get(dateTimeField26);
org.joda.time.MutableDateTime.Property property28 = mutableDateTime19.monthOfYear();
boolean boolean29 = mutableDateTime9.equals((java.lang.Object) mutableDateTime19);
mutableDateTime19.setMillis((long) 2060);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.931Z" + "'", str4, "2020-11-25T01:49:00.931Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(mutableDateTime9);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:00.931Z" + "'", str14, "2020-11-25T01:49:00.931Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 20 + "'", int18 == 20);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertNotNull(dateTimeField26);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 0 + "'", int27 == 0);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + true + "'", boolean29 == true);
}
@Test
public void test1559() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1559");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime10 = property7.add((long) 5);
org.joda.time.DateTimeField dateTimeField11 = property7.getField();
org.joda.time.MutableDateTime mutableDateTime12 = property7.roundHalfFloor();
org.joda.time.DurationField durationField13 = property7.getDurationField();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:00.971Z" + "'", str4, "2020-11-25T01:49:00.971Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(dateTimeField11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(durationField13);
}
@Test
public void test1560() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1560");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = mutableDateTime2.copy();
org.joda.time.MutableDateTime mutableDateTime5 = mutableDateTime4.toMutableDateTimeISO();
boolean boolean7 = mutableDateTime5.isBefore((long) 6281);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
}
@Test
public void test1561() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1561");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
int int8 = property7.get();
java.util.Locale locale9 = null;
int int10 = property7.getMaximumShortTextLength(locale9);
org.joda.time.MutableDateTime mutableDateTime12 = property7.addWrapField(292278993);
int int13 = mutableDateTime12.getMinuteOfDay();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime12.secondOfMinute();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:01.043Z" + "'", str4, "2020-11-25T01:49:01.043Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertTrue("'" + int13 + "' != '" + 109 + "'", int13 == 109);
org.junit.Assert.assertNotNull(property14);
}
@Test
@Ignore
public void test1562() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1562");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime2.toMutableDateTime();
java.lang.Object obj10 = mutableDateTime9.clone();
mutableDateTime9.setMillis(1580521560970L);
mutableDateTime9.add(1580521636005L);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(obj10);
// flaky: org.junit.Assert.assertEquals(obj10.toString(), "2020-02-01T01:49:01.068Z");
// flaky: org.junit.Assert.assertEquals(java.lang.String.valueOf(obj10), "2020-02-01T01:49:01.068Z");
// flaky: org.junit.Assert.assertEquals(java.util.Objects.toString(obj10), "2020-02-01T01:49:01.068Z");
}
@Test
@Ignore
public void test1563() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1563");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime13.add(readablePeriod14, 40);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime13.toMutableDateTime(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 100, chronology23);
org.joda.time.MutableDateTime mutableDateTime26 = org.joda.time.MutableDateTime.now(chronology23);
mutableDateTime26.setDate((long) 59);
org.joda.time.MutableDateTime.Property property29 = mutableDateTime26.monthOfYear();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:01.138Z" + "'", str5, "2020-11-25T01:49:01.138Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:01.138Z" + "'", str21, "2020-11-25T01:49:01.138Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(property29);
}
@Test
@Ignore
public void test1564() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1564");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfMonth();
int int3 = mutableDateTime1.getCenturyOfEra();
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology5);
mutableDateTime6.setSecondOfMinute((int) '4');
int int9 = mutableDateTime6.getMinuteOfDay();
int int10 = mutableDateTime6.getCenturyOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
int int14 = mutableDateTime13.getDayOfWeek();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.MutableDateTime mutableDateTime19 = org.joda.time.MutableDateTime.now(dateTimeZone18);
mutableDateTime13.setZoneRetainFields(dateTimeZone18);
org.joda.time.DateTime dateTime21 = mutableDateTime6.toDateTime(dateTimeZone18);
mutableDateTime1.setZoneRetainFields(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:45:00.017Z", dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(dateTimeZone18);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 20 + "'", int3 == 20);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 19 + "'", int10 == 19);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 3 + "'", int14 == 3);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime25);
}
@Test
@Ignore
public void test1565() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1565");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
java.lang.String str8 = mutableDateTime2.toString();
mutableDateTime2.setSecondOfDay(2);
int int11 = mutableDateTime2.getDayOfWeek();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
mutableDateTime14.setMinuteOfDay(4);
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
org.joda.time.Chronology chronology24 = mutableDateTime20.getChronology();
int int25 = mutableDateTime20.getWeekOfWeekyear();
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.DateTimeZone dateTimeZone29 = mutableDateTime28.getZone();
org.joda.time.DateTime dateTime30 = mutableDateTime20.toDateTime(dateTimeZone29);
org.joda.time.MutableDateTime mutableDateTime31 = mutableDateTime14.toMutableDateTime(dateTimeZone29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(dateTimeZone29);
mutableDateTime2.setZoneRetainFields(dateTimeZone29);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(dateTimeZone29);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime34.weekyear();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:01.237Z" + "'", str4, "2020-11-25T01:49:01.237Z");
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T01:49:01.237Z" + "'", str8, "2020-11-25T01:49:01.237Z");
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(dateTimeZone15);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:01.237Z" + "'", str22, "2020-11-25T01:49:01.237Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(chronology24);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 48 + "'", int25 == 48);
org.junit.Assert.assertNotNull(dateTimeZone29);
org.junit.Assert.assertNotNull(dateTime30);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(property35);
}
@Test
@Ignore
public void test1566() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1566");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime3 = property2.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime3.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime6 = property4.add(48);
org.joda.time.format.DateTimeFormatter dateTimeFormatter7 = null;
java.lang.String str8 = mutableDateTime6.toString(dateTimeFormatter7);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(mutableDateTime3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T00:00:00.048Z" + "'", str8, "2020-11-25T00:00:00.048Z");
}
@Test
@Ignore
public void test1567() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1567");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfMonth();
int int3 = mutableDateTime1.getCenturyOfEra();
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology5);
mutableDateTime6.setSecondOfMinute((int) '4');
int int9 = mutableDateTime6.getMinuteOfDay();
int int10 = mutableDateTime6.getCenturyOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
int int14 = mutableDateTime13.getDayOfWeek();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.MutableDateTime mutableDateTime19 = org.joda.time.MutableDateTime.now(dateTimeZone18);
mutableDateTime13.setZoneRetainFields(dateTimeZone18);
org.joda.time.DateTime dateTime21 = mutableDateTime6.toDateTime(dateTimeZone18);
mutableDateTime1.setZoneRetainFields(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:45:00.017Z", dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(dateTimeZone18);
// The following exception was thrown during execution in test generation
try {
mutableDateTime24.setMonthOfYear(60000);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 60000 for monthOfYear must be in the range [1,12]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 20 + "'", int3 == 20);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 19 + "'", int10 == 19);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 3 + "'", int14 == 3);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(dateTime21);
}
@Test
public void test1568() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1568");
org.joda.time.format.DateTimeFormatter dateTimeFormatter1 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime2 = org.joda.time.MutableDateTime.parse("2020-11-25T01:47:45.014Z", dateTimeFormatter1);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
public void test1569() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1569");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone4);
org.joda.time.DateTime dateTime6 = mutableDateTime5.toDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime7 = mutableDateTime5.toMutableDateTime();
boolean boolean8 = mutableDateTime7.isBeforeNow();
org.junit.Assert.assertNotNull(dateTimeZone4);
org.junit.Assert.assertNotNull(dateTime6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + true + "'", boolean8 == true);
}
@Test
@Ignore
public void test1570() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1570");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property6 = mutableDateTime3.minuteOfDay();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime3.year();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime10.dayOfWeek();
int int17 = property16.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime19 = property16.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime20 = property16.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime20.add(readablePeriod21, 40);
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.format.DateTimeFormatter dateTimeFormatter27 = null;
java.lang.String str28 = mutableDateTime26.toString(dateTimeFormatter27);
int int29 = mutableDateTime26.getYearOfCentury();
org.joda.time.Chronology chronology30 = mutableDateTime26.getChronology();
org.joda.time.MutableDateTime mutableDateTime31 = mutableDateTime20.toMutableDateTime(chronology30);
mutableDateTime3.setChronology(chronology30);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(chronology30);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj0, chronology30);
mutableDateTime34.setTime((long) 4);
org.joda.time.ReadableDuration readableDuration37 = null;
mutableDateTime34.add(readableDuration37);
org.joda.time.ReadablePeriod readablePeriod39 = null;
mutableDateTime34.add(readablePeriod39);
mutableDateTime34.setWeekOfWeekyear(9);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:01.381Z" + "'", str12, "2020-11-25T01:49:01.381Z");
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 7 + "'", int17 == 7);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:01.381Z" + "'", str28, "2020-11-25T01:49:01.381Z");
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 20 + "'", int29 == 20);
org.junit.Assert.assertNotNull(chronology30);
org.junit.Assert.assertNotNull(mutableDateTime31);
}
@Test
@Ignore
public void test1571() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1571");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
int int9 = mutableDateTime2.getRoundingMode();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.hourOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime12.dayOfWeek();
int int19 = property18.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime22 = property18.roundHalfEven();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.minuteOfHour();
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.format.DateTimeFormatter dateTimeFormatter27 = null;
java.lang.String str28 = mutableDateTime26.toString(dateTimeFormatter27);
org.joda.time.DateTimeField dateTimeField29 = mutableDateTime26.getRoundingField();
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology31);
mutableDateTime32.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property35 = mutableDateTime32.minuteOfDay();
org.joda.time.MutableDateTime.Property property36 = mutableDateTime32.year();
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
org.joda.time.format.DateTimeFormatter dateTimeFormatter40 = null;
java.lang.String str41 = mutableDateTime39.toString(dateTimeFormatter40);
org.joda.time.ReadablePeriod readablePeriod42 = null;
mutableDateTime39.add(readablePeriod42);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime39.hourOfDay();
org.joda.time.MutableDateTime.Property property45 = mutableDateTime39.dayOfWeek();
int int46 = property45.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime48 = property45.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime49 = property45.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod50 = null;
mutableDateTime49.add(readablePeriod50, 40);
java.lang.Object obj53 = null;
org.joda.time.Chronology chronology54 = null;
org.joda.time.MutableDateTime mutableDateTime55 = new org.joda.time.MutableDateTime(obj53, chronology54);
org.joda.time.format.DateTimeFormatter dateTimeFormatter56 = null;
java.lang.String str57 = mutableDateTime55.toString(dateTimeFormatter56);
int int58 = mutableDateTime55.getYearOfCentury();
org.joda.time.Chronology chronology59 = mutableDateTime55.getChronology();
org.joda.time.MutableDateTime mutableDateTime60 = mutableDateTime49.toMutableDateTime(chronology59);
mutableDateTime32.setChronology(chronology59);
mutableDateTime26.setChronology(chronology59);
org.joda.time.MutableDateTime mutableDateTime63 = mutableDateTime22.toMutableDateTime(chronology59);
int int64 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime22);
int int65 = mutableDateTime22.getDayOfYear();
boolean boolean66 = mutableDateTime22.isAfterNow();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:01.474Z" + "'", str14, "2020-11-25T01:49:01.474Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 7 + "'", int19 == 7);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(property23);
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:01.474Z" + "'", str28, "2020-11-25T01:49:01.474Z");
org.junit.Assert.assertNull(dateTimeField29);
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(property36);
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:01.474Z" + "'", str41, "2020-11-25T01:49:01.474Z");
org.junit.Assert.assertNotNull(property44);
org.junit.Assert.assertNotNull(property45);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 7 + "'", int46 == 7);
org.junit.Assert.assertNotNull(mutableDateTime48);
org.junit.Assert.assertNotNull(mutableDateTime49);
// flaky: org.junit.Assert.assertEquals("'" + str57 + "' != '" + "2020-11-25T01:49:01.474Z" + "'", str57, "2020-11-25T01:49:01.474Z");
org.junit.Assert.assertTrue("'" + int58 + "' != '" + 20 + "'", int58 == 20);
org.junit.Assert.assertNotNull(chronology59);
org.junit.Assert.assertNotNull(mutableDateTime60);
org.junit.Assert.assertNotNull(mutableDateTime63);
org.junit.Assert.assertTrue("'" + int64 + "' != '" + (-1) + "'", int64 == (-1));
org.junit.Assert.assertTrue("'" + int65 + "' != '" + 330 + "'", int65 == 330);
org.junit.Assert.assertTrue("'" + boolean66 + "' != '" + false + "'", boolean66 == false);
}
@Test
@Ignore
public void test1572() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1572");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.String str8 = mutableDateTime2.toString();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:01.535Z" + "'", str4, "2020-11-25T01:49:01.535Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T01:49:01.535Z" + "'", str8, "2020-11-25T01:49:01.535Z");
}
@Test
@Ignore
public void test1573() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1573");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.weekyear();
org.joda.time.DateTime dateTime8 = mutableDateTime2.toDateTime();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.centuryOfEra();
org.joda.time.ReadableInstant readableInstant18 = null;
mutableDateTime12.setDate(readableInstant18);
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime20.dayOfMonth();
int int22 = mutableDateTime20.getCenturyOfEra();
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology24);
mutableDateTime25.setSecondOfMinute((int) '4');
int int28 = mutableDateTime25.getMinuteOfDay();
int int29 = mutableDateTime25.getCenturyOfEra();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
int int33 = mutableDateTime32.getDayOfWeek();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
org.joda.time.DateTimeZone dateTimeZone37 = mutableDateTime36.getZone();
org.joda.time.MutableDateTime mutableDateTime38 = org.joda.time.MutableDateTime.now(dateTimeZone37);
mutableDateTime32.setZoneRetainFields(dateTimeZone37);
org.joda.time.DateTime dateTime40 = mutableDateTime25.toDateTime(dateTimeZone37);
mutableDateTime20.setZoneRetainFields(dateTimeZone37);
mutableDateTime12.setZone(dateTimeZone37);
org.joda.time.MutableDateTime mutableDateTime43 = org.joda.time.MutableDateTime.now(dateTimeZone37);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(0L, dateTimeZone37);
org.joda.time.DateTime dateTime45 = mutableDateTime2.toDateTime(dateTimeZone37);
mutableDateTime2.setSecondOfDay(21);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTime8);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:01.559Z" + "'", str14, "2020-11-25T01:49:01.559Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 0 + "'", int28 == 0);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 19 + "'", int29 == 19);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 3 + "'", int33 == 3);
org.junit.Assert.assertNotNull(dateTimeZone37);
org.junit.Assert.assertNotNull(mutableDateTime38);
org.junit.Assert.assertNotNull(dateTime40);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(dateTime45);
}
@Test
public void test1574() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1574");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:45:30.255Z");
mutableDateTime1.addWeeks((-1));
// The following exception was thrown during execution in test generation
try {
mutableDateTime1.setMonthOfYear(6414);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6414 for monthOfYear must be in the range [1,12]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1575() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1575");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
java.lang.String str8 = mutableDateTime2.toString();
mutableDateTime2.setSecondOfDay(2);
int int11 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addMonths(58);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:01.625Z" + "'", str4, "2020-11-25T01:49:01.625Z");
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T01:49:01.625Z" + "'", str8, "2020-11-25T01:49:01.625Z");
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
}
@Test
public void test1576() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1576");
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(35, 422, 376, 409, 422, 108, 1439);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 409 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1577() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1577");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.ReadableInstant readableInstant8 = null;
mutableDateTime2.setDate(readableInstant8);
java.util.Date date10 = mutableDateTime2.toDate();
mutableDateTime2.setWeekyear(10);
mutableDateTime2.add((long) 70);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.DateTimeZone dateTimeZone19 = mutableDateTime18.getZone();
mutableDateTime18.setMinuteOfDay(4);
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.format.DateTimeFormatter dateTimeFormatter25 = null;
java.lang.String str26 = mutableDateTime24.toString(dateTimeFormatter25);
int int27 = mutableDateTime24.getYearOfCentury();
org.joda.time.Chronology chronology28 = mutableDateTime24.getChronology();
int int29 = mutableDateTime24.getWeekOfWeekyear();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.DateTimeZone dateTimeZone33 = mutableDateTime32.getZone();
org.joda.time.DateTime dateTime34 = mutableDateTime24.toDateTime(dateTimeZone33);
org.joda.time.MutableDateTime mutableDateTime35 = mutableDateTime18.toMutableDateTime(dateTimeZone33);
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone33);
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
org.joda.time.format.DateTimeFormatter dateTimeFormatter40 = null;
java.lang.String str41 = mutableDateTime39.toString(dateTimeFormatter40);
org.joda.time.ReadablePeriod readablePeriod42 = null;
mutableDateTime39.add(readablePeriod42);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime39.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType45 = property44.getFieldType();
boolean boolean46 = mutableDateTime36.isSupported(dateTimeFieldType45);
boolean boolean47 = mutableDateTime2.isSupported(dateTimeFieldType45);
org.joda.time.ReadablePeriod readablePeriod48 = null;
mutableDateTime2.add(readablePeriod48);
org.joda.time.DateTime dateTime50 = mutableDateTime2.toDateTime();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:01.718Z" + "'", str4, "2020-11-25T01:49:01.718Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(date10);
// flaky: org.junit.Assert.assertEquals(date10.toString(), "Wed Nov 25 01:49:01 UTC 2020");
org.junit.Assert.assertNotNull(dateTimeZone19);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:01.718Z" + "'", str26, "2020-11-25T01:49:01.718Z");
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 20 + "'", int27 == 20);
org.junit.Assert.assertNotNull(chronology28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 48 + "'", int29 == 48);
org.junit.Assert.assertNotNull(dateTimeZone33);
org.junit.Assert.assertNotNull(dateTime34);
org.junit.Assert.assertNotNull(mutableDateTime35);
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:01.718Z" + "'", str41, "2020-11-25T01:49:01.718Z");
org.junit.Assert.assertNotNull(property44);
org.junit.Assert.assertNotNull(dateTimeFieldType45);
org.junit.Assert.assertTrue("'" + boolean46 + "' != '" + true + "'", boolean46 == true);
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + true + "'", boolean47 == true);
org.junit.Assert.assertNotNull(dateTime50);
}
@Test
@Ignore
public void test1578() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1578");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.Instant instant14 = mutableDateTime13.toInstant();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime13.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime16 = property15.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime16.toMutableDateTime();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime16.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime19 = property18.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime19.copy();
boolean boolean21 = mutableDateTime2.isBefore((org.joda.time.ReadableInstant) mutableDateTime19);
mutableDateTime2.addSeconds(29);
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.Instant instant27 = mutableDateTime26.toInstant();
org.joda.time.MutableDateTime.Property property28 = mutableDateTime26.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime29 = property28.roundHalfFloor();
java.lang.Object obj30 = mutableDateTime29.clone();
java.lang.Object obj31 = null;
org.joda.time.Chronology chronology32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(obj31, chronology32);
org.joda.time.format.DateTimeFormatter dateTimeFormatter34 = null;
java.lang.String str35 = mutableDateTime33.toString(dateTimeFormatter34);
int int36 = mutableDateTime33.getYearOfCentury();
mutableDateTime33.setMillisOfSecond(7);
java.util.Locale locale39 = null;
java.util.Calendar calendar40 = mutableDateTime33.toCalendar(locale39);
java.lang.Object obj41 = null;
org.joda.time.Chronology chronology42 = null;
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime(obj41, chronology42);
org.joda.time.Instant instant44 = mutableDateTime43.toInstant();
org.joda.time.MutableDateTime.Property property45 = mutableDateTime43.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime46 = property45.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime47 = mutableDateTime46.toMutableDateTime();
org.joda.time.MutableDateTime.Property property48 = mutableDateTime46.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime50 = property48.set(49);
org.joda.time.DurationField durationField51 = property48.getDurationField();
org.joda.time.DateTimeField dateTimeField52 = property48.getField();
int int53 = mutableDateTime33.get(dateTimeField52);
mutableDateTime29.setRounding(dateTimeField52);
java.lang.Object obj55 = mutableDateTime29.clone();
boolean boolean56 = mutableDateTime2.isEqual((org.joda.time.ReadableInstant) mutableDateTime29);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:01.768Z" + "'", str4, "2020-11-25T01:49:01.768Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(instant14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
org.junit.Assert.assertNotNull(instant27);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(obj30);
org.junit.Assert.assertEquals(obj30.toString(), "2020-12-01T00:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj30), "2020-12-01T00:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj30), "2020-12-01T00:00:00.000Z");
// flaky: org.junit.Assert.assertEquals("'" + str35 + "' != '" + "2020-11-25T01:49:01.768Z" + "'", str35, "2020-11-25T01:49:01.768Z");
org.junit.Assert.assertTrue("'" + int36 + "' != '" + 20 + "'", int36 == 20);
org.junit.Assert.assertNotNull(calendar40);
// flaky: org.junit.Assert.assertEquals(calendar40.toString(), "java.util.GregorianCalendar[time=1606268941007,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=25,DAY_OF_YEAR=330,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=1,HOUR_OF_DAY=1,MINUTE=49,SECOND=1,MILLISECOND=7,ZONE_OFFSET=0,DST_OFFSET=0]");
org.junit.Assert.assertNotNull(instant44);
org.junit.Assert.assertNotNull(property45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertNotNull(property48);
org.junit.Assert.assertNotNull(mutableDateTime50);
org.junit.Assert.assertNotNull(durationField51);
org.junit.Assert.assertNotNull(dateTimeField52);
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 20 + "'", int53 == 20);
org.junit.Assert.assertNotNull(obj55);
org.junit.Assert.assertEquals(obj55.toString(), "2020-01-01T00:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj55), "2020-01-01T00:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj55), "2020-01-01T00:00:00.000Z");
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + false + "'", boolean56 == false);
}
@Test
public void test1579() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1579");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.weekOfWeekyear();
int int9 = property8.getLeapAmount();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:01.859Z" + "'", str4, "2020-11-25T01:49:01.859Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
}
@Test
public void test1580() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1580");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.setMonthOfYear((int) (byte) 10);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundHalfCeiling();
org.joda.time.DateTimeFieldType dateTimeFieldType9 = property7.getFieldType();
java.lang.String str10 = property7.toString();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(dateTimeFieldType9);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "Property[yearOfCentury]" + "'", str10, "Property[yearOfCentury]");
}
@Test
@Ignore
public void test1581() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1581");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
int int6 = mutableDateTime2.getSecondOfMinute();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
mutableDateTime9.setTime((long) '#');
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.hourOfDay();
java.lang.String str22 = mutableDateTime16.toString();
int int23 = mutableDateTime9.compareTo((org.joda.time.ReadableInstant) mutableDateTime16);
java.lang.Object obj24 = mutableDateTime9.clone();
long long25 = mutableDateTime9.getMillis();
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.format.DateTimeFormatter dateTimeFormatter29 = null;
java.lang.String str30 = mutableDateTime28.toString(dateTimeFormatter29);
org.joda.time.ReadablePeriod readablePeriod31 = null;
mutableDateTime28.add(readablePeriod31);
org.joda.time.MutableDateTime.Property property33 = mutableDateTime28.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType34 = property33.getFieldType();
int int35 = mutableDateTime9.get(dateTimeFieldType34);
int int36 = mutableDateTime2.get(dateTimeFieldType34);
int int37 = mutableDateTime2.getSecondOfDay();
int int38 = mutableDateTime2.getMonthOfYear();
int int39 = mutableDateTime2.getSecondOfDay();
boolean boolean40 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property41 = mutableDateTime2.weekyear();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1 + "'", int6 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:01.906Z" + "'", str11, "2020-11-25T01:49:01.906Z");
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:01.906Z" + "'", str18, "2020-11-25T01:49:01.906Z");
org.junit.Assert.assertNotNull(property21);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:01.906Z" + "'", str22, "2020-11-25T01:49:01.906Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + (-1) + "'", int23 == (-1));
org.junit.Assert.assertNotNull(obj24);
org.junit.Assert.assertEquals(obj24.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj24), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj24), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long25 + "' != '" + 1606262400035L + "'", long25 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str30 + "' != '" + "2020-11-25T01:49:01.906Z" + "'", str30, "2020-11-25T01:49:01.906Z");
org.junit.Assert.assertNotNull(property33);
org.junit.Assert.assertNotNull(dateTimeFieldType34);
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 0 + "'", int35 == 0);
org.junit.Assert.assertTrue("'" + int36 + "' != '" + 1 + "'", int36 == 1);
// flaky: org.junit.Assert.assertTrue("'" + int37 + "' != '" + 6541 + "'", int37 == 6541);
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 11 + "'", int38 == 11);
// flaky: org.junit.Assert.assertTrue("'" + int39 + "' != '" + 6541 + "'", int39 == 6541);
org.junit.Assert.assertTrue("'" + boolean40 + "' != '" + false + "'", boolean40 == false);
org.junit.Assert.assertNotNull(property41);
}
@Test
@Ignore
public void test1582() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1582");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
int int6 = mutableDateTime3.getMinuteOfDay();
int int7 = mutableDateTime3.getCenturyOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
org.joda.time.MutableDateTime mutableDateTime16 = org.joda.time.MutableDateTime.now(dateTimeZone15);
mutableDateTime10.setZoneRetainFields(dateTimeZone15);
org.joda.time.DateTime dateTime18 = mutableDateTime3.toDateTime(dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((long) 1439, dateTimeZone15);
boolean boolean21 = mutableDateTime19.isBefore((long) 466);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 0 + "'", int6 == 0);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 19 + "'", int7 == 19);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
}
@Test
public void test1583() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1583");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.yearOfCentury();
int int9 = property8.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime10 = property8.roundFloor();
org.joda.time.DurationField durationField11 = property8.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfFloor();
org.joda.time.DateTimeZone dateTimeZone13 = mutableDateTime12.getZone();
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((long) 105, dateTimeZone13);
org.joda.time.ReadableDuration readableDuration15 = null;
mutableDateTime14.add(readableDuration15, (int) 'a');
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:01.988Z" + "'", str5, "2020-11-25T01:49:01.988Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(durationField11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(dateTimeZone13);
}
@Test
public void test1584() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1584");
org.joda.time.MutableDateTime mutableDateTime1 = org.joda.time.MutableDateTime.parse("2020-11-25T01:46:04.045Z");
org.junit.Assert.assertNotNull(mutableDateTime1);
}
@Test
@Ignore
public void test1585() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1585");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology5);
mutableDateTime6.setSecondOfMinute((int) '4');
int int9 = mutableDateTime6.getMinuteOfDay();
int int10 = mutableDateTime6.getCenturyOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
int int14 = mutableDateTime13.getDayOfWeek();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.MutableDateTime mutableDateTime19 = org.joda.time.MutableDateTime.now(dateTimeZone18);
mutableDateTime13.setZoneRetainFields(dateTimeZone18);
org.joda.time.DateTime dateTime21 = mutableDateTime6.toDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime22 = org.joda.time.MutableDateTime.now(dateTimeZone18);
long long23 = property2.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime22);
org.joda.time.MutableDateTime mutableDateTime25 = property2.add((long) 2189);
org.joda.time.DurationField durationField26 = property2.getDurationField();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 19 + "'", int10 == 19);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 3 + "'", int14 == 3);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertTrue("'" + long23 + "' != '" + (-50L) + "'", long23 == (-50L));
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(durationField26);
}
@Test
@Ignore
public void test1586() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1586");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.yearOfCentury();
int int13 = property12.get();
java.lang.String str14 = property12.toString();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
int int18 = mutableDateTime17.getDayOfWeek();
mutableDateTime17.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime17.secondOfMinute();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime17.weekyear();
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
int int30 = mutableDateTime25.getWeekOfWeekyear();
java.lang.Object obj31 = null;
org.joda.time.Chronology chronology32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(obj31, chronology32);
org.joda.time.DateTimeZone dateTimeZone34 = mutableDateTime33.getZone();
org.joda.time.DateTime dateTime35 = mutableDateTime25.toDateTime(dateTimeZone34);
org.joda.time.MutableDateTime mutableDateTime36 = mutableDateTime25.copy();
boolean boolean37 = mutableDateTime25.isAfterNow();
org.joda.time.MutableDateTime.Property property38 = mutableDateTime25.centuryOfEra();
int int39 = property22.getDifference((org.joda.time.ReadableInstant) mutableDateTime25);
mutableDateTime25.setSecondOfDay(21);
mutableDateTime25.addHours(104);
int int44 = property12.getDifference((org.joda.time.ReadableInstant) mutableDateTime25);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.094Z" + "'", str4, "2020-11-25T01:49:02.094Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 20 + "'", int13 == 20);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "Property[yearOfCentury]" + "'", str14, "Property[yearOfCentury]");
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 3 + "'", int18 == 3);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:02.094Z" + "'", str27, "2020-11-25T01:49:02.094Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 48 + "'", int30 == 48);
org.junit.Assert.assertNotNull(dateTimeZone34);
org.junit.Assert.assertNotNull(dateTime35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
org.junit.Assert.assertNotNull(property38);
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 0 + "'", int39 == 0);
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 0 + "'", int44 == 0);
}
@Test
public void test1587() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1587");
org.joda.time.MutableDateTime mutableDateTime0 = org.joda.time.MutableDateTime.now();
mutableDateTime0.setWeekOfWeekyear(48);
mutableDateTime0.setSecondOfDay(4);
org.junit.Assert.assertNotNull(mutableDateTime0);
}
@Test
public void test1588() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1588");
org.joda.time.MutableDateTime mutableDateTime1 = org.joda.time.MutableDateTime.parse("2020-11-25T01:47:31.369Z");
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.hourOfDay();
org.junit.Assert.assertNotNull(mutableDateTime1);
org.junit.Assert.assertNotNull(property2);
}
@Test
@Ignore
public void test1589() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1589");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.weekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
int int13 = mutableDateTime10.getYearOfCentury();
org.joda.time.Chronology chronology14 = mutableDateTime10.getChronology();
int int15 = mutableDateTime10.getWeekOfWeekyear();
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.DateTimeZone dateTimeZone19 = mutableDateTime18.getZone();
org.joda.time.DateTime dateTime20 = mutableDateTime10.toDateTime(dateTimeZone19);
org.joda.time.MutableDateTime mutableDateTime21 = mutableDateTime10.copy();
boolean boolean22 = mutableDateTime10.isAfterNow();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime10.centuryOfEra();
int int24 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime10);
mutableDateTime10.setSecondOfDay(21);
mutableDateTime10.addHours(104);
org.joda.time.MutableDateTime mutableDateTime29 = mutableDateTime10.toMutableDateTime();
java.util.Locale locale30 = null;
java.util.Calendar calendar31 = mutableDateTime10.toCalendar(locale30);
mutableDateTime10.setYear(60000);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:02.186Z" + "'", str12, "2020-11-25T01:49:02.186Z");
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 20 + "'", int13 == 20);
org.junit.Assert.assertNotNull(chronology14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 48 + "'", int15 == 48);
org.junit.Assert.assertNotNull(dateTimeZone19);
org.junit.Assert.assertNotNull(dateTime20);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 0 + "'", int24 == 0);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(calendar31);
// flaky: org.junit.Assert.assertEquals(calendar31.toString(), "java.util.GregorianCalendar[time=1606636821186,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=10,WEEK_OF_YEAR=49,WEEK_OF_MONTH=5,DAY_OF_MONTH=29,DAY_OF_YEAR=334,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=5,AM_PM=0,HOUR=8,HOUR_OF_DAY=8,MINUTE=0,SECOND=21,MILLISECOND=186,ZONE_OFFSET=0,DST_OFFSET=0]");
}
@Test
@Ignore
public void test1590() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1590");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
org.joda.time.Chronology chronology24 = mutableDateTime20.getChronology();
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(chronology24);
org.joda.time.MutableDateTime mutableDateTime26 = mutableDateTime2.toMutableDateTime(chronology24);
mutableDateTime26.addWeekyears((int) (short) 1);
org.joda.time.MutableDateTime mutableDateTime29 = mutableDateTime26.toMutableDateTimeISO();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.217Z" + "'", str4, "2020-11-25T01:49:02.217Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:02.217Z" + "'", str11, "2020-11-25T01:49:02.217Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:02.217Z" + "'", str15, "2020-11-25T01:49:02.217Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:02.218Z" + "'", str22, "2020-11-25T01:49:02.218Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(chronology24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(mutableDateTime29);
}
@Test
@Ignore
public void test1591() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1591");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
int int6 = mutableDateTime2.getCenturyOfEra();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
int int10 = mutableDateTime9.getDayOfWeek();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.DateTimeZone dateTimeZone14 = mutableDateTime13.getZone();
org.joda.time.MutableDateTime mutableDateTime15 = org.joda.time.MutableDateTime.now(dateTimeZone14);
mutableDateTime9.setZoneRetainFields(dateTimeZone14);
org.joda.time.DateTime dateTime17 = mutableDateTime2.toDateTime(dateTimeZone14);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
int int19 = mutableDateTime2.getHourOfDay();
java.lang.Class<?> wildcardClass20 = mutableDateTime2.getClass();
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 19 + "'", int6 == 19);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 3 + "'", int10 == 3);
org.junit.Assert.assertNotNull(dateTimeZone14);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertNotNull(dateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 0 + "'", int19 == 0);
org.junit.Assert.assertNotNull(wildcardClass20);
}
@Test
public void test1592() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1592");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.secondOfMinute();
org.joda.time.MutableDateTime mutableDateTime11 = property10.roundHalfCeiling();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
mutableDateTime14.setMinuteOfDay(4);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime14.dayOfWeek();
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime14.add(readablePeriod19);
int int21 = mutableDateTime14.getEra();
int int22 = property10.getDifference((org.joda.time.ReadableInstant) mutableDateTime14);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.282Z" + "'", str4, "2020-11-25T01:49:02.282Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 1 + "'", int21 == 1);
// flaky: org.junit.Assert.assertTrue("'" + int22 + "' != '" + (-659577842) + "'", int22 == (-659577842));
}
@Test
@Ignore
public void test1593() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1593");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime10 = property8.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.Interval interval12 = property11.toInterval();
org.joda.time.DurationField durationField13 = property11.getLeapDurationField();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
mutableDateTime17.setMinuteOfDay(4);
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
int int26 = mutableDateTime23.getYearOfCentury();
org.joda.time.Chronology chronology27 = mutableDateTime23.getChronology();
int int28 = mutableDateTime23.getWeekOfWeekyear();
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.DateTimeZone dateTimeZone32 = mutableDateTime31.getZone();
org.joda.time.DateTime dateTime33 = mutableDateTime23.toDateTime(dateTimeZone32);
org.joda.time.MutableDateTime mutableDateTime34 = mutableDateTime17.toMutableDateTime(dateTimeZone32);
org.joda.time.MutableDateTime mutableDateTime35 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone32);
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
org.joda.time.ReadablePeriod readablePeriod41 = null;
mutableDateTime38.add(readablePeriod41);
org.joda.time.MutableDateTime.Property property43 = mutableDateTime38.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType44 = property43.getFieldType();
boolean boolean45 = mutableDateTime35.isSupported(dateTimeFieldType44);
org.joda.time.MutableDateTime.Property property46 = mutableDateTime35.minuteOfDay();
org.joda.time.DateTimeZone dateTimeZone47 = null;
mutableDateTime35.setZone(dateTimeZone47);
int int49 = property11.getDifference((org.joda.time.ReadableInstant) mutableDateTime35);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.306Z" + "'", str4, "2020-11-25T01:49:02.306Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(interval12);
org.junit.Assert.assertNull(durationField13);
org.junit.Assert.assertNotNull(dateTimeZone18);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:02.306Z" + "'", str25, "2020-11-25T01:49:02.306Z");
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
org.junit.Assert.assertNotNull(chronology27);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 48 + "'", int28 == 48);
org.junit.Assert.assertNotNull(dateTimeZone32);
org.junit.Assert.assertNotNull(dateTime33);
org.junit.Assert.assertNotNull(mutableDateTime34);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:02.306Z" + "'", str40, "2020-11-25T01:49:02.306Z");
org.junit.Assert.assertNotNull(property43);
org.junit.Assert.assertNotNull(dateTimeFieldType44);
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + true + "'", boolean45 == true);
org.junit.Assert.assertNotNull(property46);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 18590 + "'", int49 == 18590);
}
@Test
public void test1594() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1594");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime mutableDateTime9 = property7.add((long) 422);
int int10 = mutableDateTime9.getMillisOfDay();
org.joda.time.MutableDateTime mutableDateTime12 = org.joda.time.MutableDateTime.parse("2020-11-25T01:44:51.967Z");
int int13 = mutableDateTime12.getSecondOfDay();
int int14 = mutableDateTime9.compareTo((org.joda.time.ReadableInstant) mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.393Z" + "'", str4, "2020-11-25T01:49:02.393Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
// flaky: org.junit.Assert.assertTrue("'" + int10 + "' != '" + 56942393 + "'", int10 == 56942393);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 6291 + "'", int13 == 6291);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 1 + "'", int14 == 1);
}
@Test
public void test1595() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1595");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime11 = property7.add((-331347996000L));
org.junit.Assert.fail("Expected exception of type java.lang.ArithmeticException; message: Value cannot fit in an int: -33134799600000");
} catch (java.lang.ArithmeticException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.417Z" + "'", str4, "2020-11-25T01:49:02.417Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime9);
}
@Test
public void test1596() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1596");
java.lang.Object obj2 = null;
org.joda.time.Chronology chronology3 = null;
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime(obj2, chronology3);
org.joda.time.DateTimeZone dateTimeZone5 = mutableDateTime4.getZone();
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone5);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone5);
mutableDateTime7.setSecondOfMinute((int) (short) 0);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime7.year();
org.joda.time.MutableDateTime mutableDateTime11 = property10.roundHalfEven();
org.junit.Assert.assertNotNull(dateTimeZone5);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
@Test
@Ignore
public void test1597() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1597");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
java.lang.Object obj17 = mutableDateTime2.clone();
long long18 = mutableDateTime2.getMillis();
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
int int20 = mutableDateTime19.getWeekOfWeekyear();
int int21 = mutableDateTime19.getMillisOfDay();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.465Z" + "'", str4, "2020-11-25T01:49:02.465Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:02.465Z" + "'", str11, "2020-11-25T01:49:02.465Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:02.465Z" + "'", str15, "2020-11-25T01:49:02.465Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(obj17);
org.junit.Assert.assertEquals(obj17.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long18 + "' != '" + 1606262400035L + "'", long18 == 1606262400035L);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 48 + "'", int20 == 48);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 35 + "'", int21 == 35);
}
@Test
@Ignore
public void test1598() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1598");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.Interval interval4 = property2.toInterval();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.format.DateTimeFormatter dateTimeFormatter8 = null;
java.lang.String str9 = mutableDateTime7.toString(dateTimeFormatter8);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime7.add(readablePeriod10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime7.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime7.toMutableDateTimeISO();
int int14 = mutableDateTime7.getSecondOfDay();
int int15 = property2.getDifference((org.joda.time.ReadableInstant) mutableDateTime7);
boolean boolean16 = mutableDateTime7.isEqualNow();
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology18);
mutableDateTime19.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property22 = mutableDateTime19.minuteOfDay();
org.joda.time.MutableDateTime mutableDateTime23 = property22.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property24 = mutableDateTime23.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime25.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime27 = property26.getMutableDateTime();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
int int31 = mutableDateTime30.getDayOfWeek();
mutableDateTime30.addSeconds((int) (byte) 0);
int int34 = mutableDateTime30.getSecondOfMinute();
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
mutableDateTime37.setTime((long) '#');
java.lang.Object obj42 = null;
org.joda.time.Chronology chronology43 = null;
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(obj42, chronology43);
org.joda.time.format.DateTimeFormatter dateTimeFormatter45 = null;
java.lang.String str46 = mutableDateTime44.toString(dateTimeFormatter45);
org.joda.time.ReadablePeriod readablePeriod47 = null;
mutableDateTime44.add(readablePeriod47);
org.joda.time.MutableDateTime.Property property49 = mutableDateTime44.hourOfDay();
java.lang.String str50 = mutableDateTime44.toString();
int int51 = mutableDateTime37.compareTo((org.joda.time.ReadableInstant) mutableDateTime44);
java.lang.Object obj52 = mutableDateTime37.clone();
long long53 = mutableDateTime37.getMillis();
java.lang.Object obj54 = null;
org.joda.time.Chronology chronology55 = null;
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime(obj54, chronology55);
org.joda.time.format.DateTimeFormatter dateTimeFormatter57 = null;
java.lang.String str58 = mutableDateTime56.toString(dateTimeFormatter57);
org.joda.time.ReadablePeriod readablePeriod59 = null;
mutableDateTime56.add(readablePeriod59);
org.joda.time.MutableDateTime.Property property61 = mutableDateTime56.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType62 = property61.getFieldType();
int int63 = mutableDateTime37.get(dateTimeFieldType62);
int int64 = mutableDateTime30.get(dateTimeFieldType62);
boolean boolean65 = mutableDateTime27.isSupported(dateTimeFieldType62);
int int66 = mutableDateTime23.get(dateTimeFieldType62);
int int67 = mutableDateTime7.get(dateTimeFieldType62);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(interval4);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:02.494Z" + "'", str9, "2020-11-25T01:49:02.494Z");
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertTrue("'" + int14 + "' != '" + 6542 + "'", int14 == 6542);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
// flaky: org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + true + "'", boolean16 == true);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(property24);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 3 + "'", int31 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int34 + "' != '" + 2 + "'", int34 == 2);
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:02.494Z" + "'", str39, "2020-11-25T01:49:02.494Z");
// flaky: org.junit.Assert.assertEquals("'" + str46 + "' != '" + "2020-11-25T01:49:02.494Z" + "'", str46, "2020-11-25T01:49:02.494Z");
org.junit.Assert.assertNotNull(property49);
// flaky: org.junit.Assert.assertEquals("'" + str50 + "' != '" + "2020-11-25T01:49:02.494Z" + "'", str50, "2020-11-25T01:49:02.494Z");
org.junit.Assert.assertTrue("'" + int51 + "' != '" + (-1) + "'", int51 == (-1));
org.junit.Assert.assertNotNull(obj52);
org.junit.Assert.assertEquals(obj52.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj52), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj52), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long53 + "' != '" + 1606262400035L + "'", long53 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str58 + "' != '" + "2020-11-25T01:49:02.494Z" + "'", str58, "2020-11-25T01:49:02.494Z");
org.junit.Assert.assertNotNull(property61);
org.junit.Assert.assertNotNull(dateTimeFieldType62);
org.junit.Assert.assertTrue("'" + int63 + "' != '" + 0 + "'", int63 == 0);
org.junit.Assert.assertTrue("'" + int64 + "' != '" + 1 + "'", int64 == 1);
org.junit.Assert.assertTrue("'" + boolean65 + "' != '" + true + "'", boolean65 == true);
org.junit.Assert.assertTrue("'" + int66 + "' != '" + 0 + "'", int66 == 0);
org.junit.Assert.assertTrue("'" + int67 + "' != '" + 1 + "'", int67 == 1);
}
@Test
@Ignore
public void test1599() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1599");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
int int7 = property6.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime8 = property6.roundHalfCeiling();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 59 + "'", int7 == 59);
org.junit.Assert.assertNotNull(mutableDateTime8);
}
@Test
@Ignore
public void test1600() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1600");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
mutableDateTime2.setMillisOfDay(0);
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
mutableDateTime23.setTime((long) '#');
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
java.lang.String str36 = mutableDateTime30.toString();
int int37 = mutableDateTime23.compareTo((org.joda.time.ReadableInstant) mutableDateTime30);
org.joda.time.MutableDateTime mutableDateTime38 = mutableDateTime23.copy();
java.lang.Object obj39 = null;
org.joda.time.Chronology chronology40 = null;
org.joda.time.MutableDateTime mutableDateTime41 = new org.joda.time.MutableDateTime(obj39, chronology40);
org.joda.time.format.DateTimeFormatter dateTimeFormatter42 = null;
java.lang.String str43 = mutableDateTime41.toString(dateTimeFormatter42);
int int44 = mutableDateTime41.getYearOfCentury();
org.joda.time.Chronology chronology45 = mutableDateTime41.getChronology();
org.joda.time.MutableDateTime mutableDateTime46 = org.joda.time.MutableDateTime.now(chronology45);
org.joda.time.MutableDateTime mutableDateTime47 = mutableDateTime23.toMutableDateTime(chronology45);
org.joda.time.MutableDateTime mutableDateTime48 = mutableDateTime2.toMutableDateTime(chronology45);
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setHourOfDay(6351);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6351 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.692Z" + "'", str4, "2020-11-25T01:49:02.692Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:02.692Z" + "'", str11, "2020-11-25T01:49:02.692Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:02.692Z" + "'", str15, "2020-11-25T01:49:02.692Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:02.692Z" + "'", str25, "2020-11-25T01:49:02.692Z");
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:02.692Z" + "'", str32, "2020-11-25T01:49:02.692Z");
org.junit.Assert.assertNotNull(property35);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:02.692Z" + "'", str36, "2020-11-25T01:49:02.692Z");
org.junit.Assert.assertTrue("'" + int37 + "' != '" + (-1) + "'", int37 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime38);
// flaky: org.junit.Assert.assertEquals("'" + str43 + "' != '" + "2020-11-25T01:49:02.692Z" + "'", str43, "2020-11-25T01:49:02.692Z");
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 20 + "'", int44 == 20);
org.junit.Assert.assertNotNull(chronology45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertNotNull(mutableDateTime48);
}
@Test
@Ignore
public void test1601() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1601");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
org.joda.time.DateTimeField dateTimeField19 = property18.getField();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
org.joda.time.ReadablePeriod readablePeriod25 = null;
mutableDateTime22.add(readablePeriod25);
org.joda.time.MutableDateTime.Property property27 = mutableDateTime22.hourOfDay();
org.joda.time.MutableDateTime.Property property28 = mutableDateTime22.dayOfWeek();
int int29 = property28.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime31 = property28.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime32 = property28.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime32.add(readablePeriod33, 40);
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
int int41 = mutableDateTime38.getYearOfCentury();
org.joda.time.Chronology chronology42 = mutableDateTime38.getChronology();
org.joda.time.MutableDateTime mutableDateTime43 = mutableDateTime32.toMutableDateTime(chronology42);
org.joda.time.MutableDateTime mutableDateTime44 = org.joda.time.MutableDateTime.now(chronology42);
org.joda.time.MutableDateTime.Property property45 = mutableDateTime44.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime46 = mutableDateTime44.copy();
long long47 = property18.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime46);
// The following exception was thrown during execution in test generation
try {
mutableDateTime46.setMonthOfYear(259);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 259 for monthOfYear must be in the range [1,12]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.769Z" + "'", str4, "2020-11-25T01:49:02.769Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:02.769Z" + "'", str11, "2020-11-25T01:49:02.769Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:02.769Z" + "'", str15, "2020-11-25T01:49:02.769Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeField19);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:02.769Z" + "'", str24, "2020-11-25T01:49:02.769Z");
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 7 + "'", int29 == 7);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime32);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:02.769Z" + "'", str40, "2020-11-25T01:49:02.769Z");
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 20 + "'", int41 == 20);
org.junit.Assert.assertNotNull(chronology42);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(mutableDateTime44);
org.junit.Assert.assertNotNull(property45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertTrue("'" + long47 + "' != '" + 0L + "'", long47 == 0L);
}
@Test
public void test1602() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1602");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.year();
java.lang.String str15 = mutableDateTime12.toString("330");
org.joda.time.MutableDateTime.Property property16 = mutableDateTime12.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime17 = property16.roundHalfFloor();
int int18 = property16.getMaximumValueOverall();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.813Z" + "'", str4, "2020-11-25T01:49:02.813Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "330" + "'", str15, "330");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 99 + "'", int18 == 99);
}
@Test
public void test1603() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1603");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
int int8 = property7.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.centuryOfEra();
java.util.Locale locale11 = null;
int int12 = property10.getMaximumShortTextLength(locale11);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:02.940Z" + "'", str4, "2020-11-25T01:49:02.940Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 7 + "'", int12 == 7);
}
@Test
@Ignore
public void test1604() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1604");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime2.millisOfDay();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.021Z" + "'", str4, "2020-11-25T01:49:03.021Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(property11);
}
@Test
public void test1605() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1605");
org.joda.time.format.DateTimeFormatter dateTimeFormatter1 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime2 = org.joda.time.MutableDateTime.parse("2020-11-25T01:47:16.227Z", dateTimeFormatter1);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1606() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1606");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
long long13 = property8.remainder();
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime14.dayOfMonth();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime14.dayOfMonth();
java.lang.String str17 = property16.getAsString();
org.joda.time.Interval interval18 = property16.toInterval();
boolean boolean19 = property8.equals((java.lang.Object) interval18);
org.joda.time.DurationField durationField20 = property8.getRangeDurationField();
java.util.Locale locale21 = null;
int int22 = property8.getMaximumShortTextLength(locale21);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.113Z" + "'", str4, "2020-11-25T01:49:03.113Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertTrue("'" + long13 + "' != '" + 0L + "'", long13 == 0L);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "25" + "'", str17, "25");
org.junit.Assert.assertNotNull(interval18);
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + false + "'", boolean19 == false);
org.junit.Assert.assertNotNull(durationField20);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 3 + "'", int22 == 3);
}
@Test
@Ignore
public void test1607() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1607");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime10 = property7.getMutableDateTime();
int int11 = mutableDateTime10.getEra();
mutableDateTime10.setDayOfWeek(7);
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
int int17 = mutableDateTime16.getDayOfWeek();
mutableDateTime16.addSeconds((int) (byte) 0);
mutableDateTime16.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property22 = mutableDateTime16.millisOfSecond();
int int23 = property22.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime24 = property22.roundHalfCeiling();
mutableDateTime10.setTime((org.joda.time.ReadableInstant) mutableDateTime24);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.248Z" + "'", str4, "2020-11-25T01:49:03.248Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 1 + "'", int11 == 1);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 3 + "'", int17 == 3);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 0 + "'", int23 == 0);
org.junit.Assert.assertNotNull(mutableDateTime24);
}
@Test
@Ignore
public void test1608() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1608");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
org.joda.time.ReadableDuration readableDuration15 = null;
mutableDateTime13.add(readableDuration15);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.281Z" + "'", str4, "2020-11-25T01:49:03.281Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
}
@Test
@Ignore
public void test1609() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1609");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
int int7 = mutableDateTime2.getWeekOfWeekyear();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
}
@Test
@Ignore
public void test1610() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1610");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime13 = property8.roundHalfFloor();
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology15);
mutableDateTime16.setSecondOfMinute((int) '4');
int int19 = mutableDateTime16.getMinuteOfDay();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
org.joda.time.ReadablePeriod readablePeriod26 = null;
mutableDateTime23.add(readablePeriod26);
org.joda.time.MutableDateTime.Property property28 = mutableDateTime23.centuryOfEra();
org.joda.time.DateTimeField dateTimeField29 = property28.getField();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
org.joda.time.ReadablePeriod readablePeriod35 = null;
mutableDateTime32.add(readablePeriod35);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime32.centuryOfEra();
int int38 = property28.getDifference((org.joda.time.ReadableInstant) mutableDateTime32);
org.joda.time.MutableDateTime mutableDateTime39 = mutableDateTime32.toMutableDateTimeISO();
java.lang.Object obj40 = null;
org.joda.time.Chronology chronology41 = null;
org.joda.time.MutableDateTime mutableDateTime42 = new org.joda.time.MutableDateTime(obj40, chronology41);
org.joda.time.DateTimeZone dateTimeZone43 = mutableDateTime42.getZone();
org.joda.time.MutableDateTime mutableDateTime44 = mutableDateTime39.toMutableDateTime(dateTimeZone43);
org.joda.time.MutableDateTime mutableDateTime45 = new org.joda.time.MutableDateTime((long) 815, dateTimeZone43);
mutableDateTime16.setZoneRetainFields(dateTimeZone43);
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime13, dateTimeZone43);
mutableDateTime47.setMillisOfSecond(3);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.369Z" + "'", str4, "2020-11-25T01:49:03.369Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 0 + "'", int19 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:03.369Z" + "'", str25, "2020-11-25T01:49:03.369Z");
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertNotNull(dateTimeField29);
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:03.369Z" + "'", str34, "2020-11-25T01:49:03.369Z");
org.junit.Assert.assertNotNull(property37);
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 0 + "'", int38 == 0);
org.junit.Assert.assertNotNull(mutableDateTime39);
org.junit.Assert.assertNotNull(dateTimeZone43);
org.junit.Assert.assertNotNull(mutableDateTime44);
}
@Test
@Ignore
public void test1611() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1611");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
org.joda.time.MutableDateTime mutableDateTime24 = org.joda.time.MutableDateTime.now(chronology22);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfYear();
java.lang.String str26 = property25.getName();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.456Z" + "'", str4, "2020-11-25T01:49:03.456Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:03.456Z" + "'", str20, "2020-11-25T01:49:03.456Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "dayOfYear" + "'", str26, "dayOfYear");
}
@Test
@Ignore
public void test1612() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1612");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.minuteOfHour();
java.lang.Object obj14 = mutableDateTime12.clone();
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15, 6386);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.481Z" + "'", str4, "2020-11-25T01:49:03.481Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(obj14);
org.junit.Assert.assertEquals(obj14.toString(), "2020-11-25T00:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj14), "2020-11-25T00:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj14), "2020-11-25T00:00:00.000Z");
}
@Test
public void test1613() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1613");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = property3.roundCeiling();
mutableDateTime4.setHourOfDay((int) (byte) 0);
mutableDateTime4.addMonths(4);
mutableDateTime4.addHours(2020);
org.joda.time.Chronology chronology11 = mutableDateTime4.getChronology();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(chronology11);
}
@Test
@Ignore
public void test1614() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1614");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.weekyear();
mutableDateTime2.addWeeks(259);
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
int int15 = mutableDateTime14.getDayOfWeek();
mutableDateTime14.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime14.secondOfMinute();
org.joda.time.MutableDateTime.Property property19 = mutableDateTime14.weekyear();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
int int25 = mutableDateTime22.getYearOfCentury();
org.joda.time.Chronology chronology26 = mutableDateTime22.getChronology();
int int27 = mutableDateTime22.getWeekOfWeekyear();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.DateTimeZone dateTimeZone31 = mutableDateTime30.getZone();
org.joda.time.DateTime dateTime32 = mutableDateTime22.toDateTime(dateTimeZone31);
org.joda.time.MutableDateTime mutableDateTime33 = mutableDateTime22.copy();
boolean boolean34 = mutableDateTime22.isAfterNow();
org.joda.time.MutableDateTime.Property property35 = mutableDateTime22.centuryOfEra();
int int36 = property19.getDifference((org.joda.time.ReadableInstant) mutableDateTime22);
mutableDateTime22.setSecondOfDay(21);
mutableDateTime22.addHours(104);
java.lang.Object obj41 = null;
org.joda.time.Chronology chronology42 = null;
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime(obj41, chronology42);
org.joda.time.format.DateTimeFormatter dateTimeFormatter44 = null;
java.lang.String str45 = mutableDateTime43.toString(dateTimeFormatter44);
org.joda.time.ReadablePeriod readablePeriod46 = null;
mutableDateTime43.add(readablePeriod46);
org.joda.time.MutableDateTime.Property property48 = mutableDateTime43.centuryOfEra();
org.joda.time.ReadableInstant readableInstant49 = null;
mutableDateTime43.setDate(readableInstant49);
org.joda.time.MutableDateTime mutableDateTime51 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property52 = mutableDateTime51.dayOfMonth();
int int53 = mutableDateTime51.getCenturyOfEra();
org.joda.time.Chronology chronology55 = null;
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology55);
mutableDateTime56.setSecondOfMinute((int) '4');
int int59 = mutableDateTime56.getMinuteOfDay();
int int60 = mutableDateTime56.getCenturyOfEra();
java.lang.Object obj61 = null;
org.joda.time.Chronology chronology62 = null;
org.joda.time.MutableDateTime mutableDateTime63 = new org.joda.time.MutableDateTime(obj61, chronology62);
int int64 = mutableDateTime63.getDayOfWeek();
java.lang.Object obj65 = null;
org.joda.time.Chronology chronology66 = null;
org.joda.time.MutableDateTime mutableDateTime67 = new org.joda.time.MutableDateTime(obj65, chronology66);
org.joda.time.DateTimeZone dateTimeZone68 = mutableDateTime67.getZone();
org.joda.time.MutableDateTime mutableDateTime69 = org.joda.time.MutableDateTime.now(dateTimeZone68);
mutableDateTime63.setZoneRetainFields(dateTimeZone68);
org.joda.time.DateTime dateTime71 = mutableDateTime56.toDateTime(dateTimeZone68);
mutableDateTime51.setZoneRetainFields(dateTimeZone68);
mutableDateTime43.setZone(dateTimeZone68);
org.joda.time.MutableDateTime mutableDateTime74 = org.joda.time.MutableDateTime.now(dateTimeZone68);
mutableDateTime22.setZoneRetainFields(dateTimeZone68);
org.joda.time.MutableDateTime mutableDateTime76 = mutableDateTime2.toMutableDateTime(dateTimeZone68);
int int77 = mutableDateTime76.getYearOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.610Z" + "'", str4, "2020-11-25T01:49:03.610Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 3 + "'", int15 == 3);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(property19);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:03.610Z" + "'", str24, "2020-11-25T01:49:03.610Z");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 20 + "'", int25 == 20);
org.junit.Assert.assertNotNull(chronology26);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 48 + "'", int27 == 48);
org.junit.Assert.assertNotNull(dateTimeZone31);
org.junit.Assert.assertNotNull(dateTime32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + false + "'", boolean34 == false);
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertTrue("'" + int36 + "' != '" + 0 + "'", int36 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str45 + "' != '" + "2020-11-25T01:49:03.611Z" + "'", str45, "2020-11-25T01:49:03.611Z");
org.junit.Assert.assertNotNull(property48);
org.junit.Assert.assertNotNull(property52);
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 20 + "'", int53 == 20);
org.junit.Assert.assertTrue("'" + int59 + "' != '" + 0 + "'", int59 == 0);
org.junit.Assert.assertTrue("'" + int60 + "' != '" + 19 + "'", int60 == 19);
org.junit.Assert.assertTrue("'" + int64 + "' != '" + 3 + "'", int64 == 3);
org.junit.Assert.assertNotNull(dateTimeZone68);
org.junit.Assert.assertNotNull(mutableDateTime69);
org.junit.Assert.assertNotNull(dateTime71);
org.junit.Assert.assertNotNull(mutableDateTime74);
org.junit.Assert.assertNotNull(mutableDateTime76);
org.junit.Assert.assertTrue("'" + int77 + "' != '" + 2025 + "'", int77 == 2025);
}
@Test
@Ignore
public void test1615() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1615");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.DateTimeZone dateTimeZone13 = mutableDateTime2.getZone();
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(dateTimeZone13);
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
int int19 = mutableDateTime17.getSecondOfMinute();
int int20 = mutableDateTime17.getMonthOfYear();
int int21 = mutableDateTime17.getMillisOfSecond();
int int22 = mutableDateTime17.getMinuteOfHour();
org.joda.time.DateTime dateTime23 = mutableDateTime17.toDateTimeISO();
boolean boolean24 = mutableDateTime14.isAfter((org.joda.time.ReadableInstant) mutableDateTime17);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime14.dayOfWeek();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.686Z" + "'", str4, "2020-11-25T01:49:03.686Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(dateTimeZone13);
org.junit.Assert.assertNotNull(dateTimeZone18);
// flaky: org.junit.Assert.assertTrue("'" + int19 + "' != '" + 3 + "'", int19 == 3);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 11 + "'", int20 == 11);
// flaky: org.junit.Assert.assertTrue("'" + int21 + "' != '" + 686 + "'", int21 == 686);
// flaky: org.junit.Assert.assertTrue("'" + int22 + "' != '" + 49 + "'", int22 == 49);
org.junit.Assert.assertNotNull(dateTime23);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
org.junit.Assert.assertNotNull(property25);
}
@Test
@Ignore
public void test1616() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1616");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime13.add(readablePeriod14, 40);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime13.toMutableDateTime(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 100, chronology23);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime25.dayOfYear();
int int27 = mutableDateTime25.getDayOfMonth();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:03.765Z" + "'", str5, "2020-11-25T01:49:03.765Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:03.765Z" + "'", str21, "2020-11-25T01:49:03.765Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 1 + "'", int27 == 1);
}
@Test
@Ignore
public void test1617() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1617");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) 100, chronology29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology29);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.DateTime dateTime35 = mutableDateTime34.toDateTimeISO();
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology38);
org.joda.time.MutableDateTime.Property property40 = mutableDateTime39.dayOfYear();
java.util.GregorianCalendar gregorianCalendar41 = mutableDateTime39.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property42 = mutableDateTime39.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property44 = mutableDateTime43.dayOfMonth();
int int45 = mutableDateTime43.getCenturyOfEra();
org.joda.time.Chronology chronology47 = null;
org.joda.time.MutableDateTime mutableDateTime48 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology47);
mutableDateTime48.setSecondOfMinute((int) '4');
int int51 = mutableDateTime48.getMinuteOfDay();
int int52 = mutableDateTime48.getCenturyOfEra();
java.lang.Object obj53 = null;
org.joda.time.Chronology chronology54 = null;
org.joda.time.MutableDateTime mutableDateTime55 = new org.joda.time.MutableDateTime(obj53, chronology54);
int int56 = mutableDateTime55.getDayOfWeek();
java.lang.Object obj57 = null;
org.joda.time.Chronology chronology58 = null;
org.joda.time.MutableDateTime mutableDateTime59 = new org.joda.time.MutableDateTime(obj57, chronology58);
org.joda.time.DateTimeZone dateTimeZone60 = mutableDateTime59.getZone();
org.joda.time.MutableDateTime mutableDateTime61 = org.joda.time.MutableDateTime.now(dateTimeZone60);
mutableDateTime55.setZoneRetainFields(dateTimeZone60);
org.joda.time.DateTime dateTime63 = mutableDateTime48.toDateTime(dateTimeZone60);
mutableDateTime43.setZoneRetainFields(dateTimeZone60);
org.joda.time.MutableDateTime mutableDateTime65 = org.joda.time.MutableDateTime.now(dateTimeZone60);
org.joda.time.MutableDateTime mutableDateTime66 = mutableDateTime39.toMutableDateTime(dateTimeZone60);
org.joda.time.MutableDateTime mutableDateTime67 = new org.joda.time.MutableDateTime((long) '#', dateTimeZone60);
boolean boolean68 = dateTime35.isAfter((org.joda.time.ReadableInstant) mutableDateTime67);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:03.800Z" + "'", str11, "2020-11-25T01:49:03.800Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:03.800Z" + "'", str27, "2020-11-25T01:49:03.800Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(dateTime35);
org.junit.Assert.assertNotNull(property40);
org.junit.Assert.assertNotNull(gregorianCalendar41);
org.junit.Assert.assertNotNull(property42);
org.junit.Assert.assertNotNull(property44);
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 20 + "'", int45 == 20);
org.junit.Assert.assertTrue("'" + int51 + "' != '" + 0 + "'", int51 == 0);
org.junit.Assert.assertTrue("'" + int52 + "' != '" + 19 + "'", int52 == 19);
org.junit.Assert.assertTrue("'" + int56 + "' != '" + 3 + "'", int56 == 3);
org.junit.Assert.assertNotNull(dateTimeZone60);
org.junit.Assert.assertNotNull(mutableDateTime61);
org.junit.Assert.assertNotNull(dateTime63);
org.junit.Assert.assertNotNull(mutableDateTime65);
org.junit.Assert.assertNotNull(mutableDateTime66);
org.junit.Assert.assertTrue("'" + boolean68 + "' != '" + true + "'", boolean68 == true);
}
@Test
@Ignore
public void test1618() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1618");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.minuteOfDay();
java.lang.String str9 = property8.getAsString();
org.joda.time.ReadablePartial readablePartial10 = null;
// The following exception was thrown during execution in test generation
try {
int int11 = property8.compareTo(readablePartial10);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: The partial must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:03.904Z" + "'", str4, "2020-11-25T01:49:03.904Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(property8);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "109" + "'", str9, "109");
}
@Test
@Ignore
public void test1619() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1619");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
int int6 = mutableDateTime3.getMinuteOfDay();
int int7 = mutableDateTime3.getCenturyOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
org.joda.time.MutableDateTime mutableDateTime16 = org.joda.time.MutableDateTime.now(dateTimeZone15);
mutableDateTime10.setZoneRetainFields(dateTimeZone15);
org.joda.time.DateTime dateTime18 = mutableDateTime3.toDateTime(dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(259200010L, dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime20 = org.joda.time.MutableDateTime.now();
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(0L);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
org.joda.time.ReadablePeriod readablePeriod28 = null;
mutableDateTime25.add(readablePeriod28);
org.joda.time.MutableDateTime.Property property30 = mutableDateTime25.hourOfDay();
org.joda.time.MutableDateTime.Property property31 = mutableDateTime25.dayOfWeek();
int int32 = property31.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime33 = property31.roundHalfCeiling();
org.joda.time.DateTimeField dateTimeField34 = property31.getField();
mutableDateTime22.setRounding(dateTimeField34);
int int36 = mutableDateTime20.get(dateTimeField34);
int int37 = mutableDateTime19.get(dateTimeField34);
org.joda.time.Instant instant38 = mutableDateTime19.toInstant();
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 0 + "'", int6 == 0);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 19 + "'", int7 == 19);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(mutableDateTime20);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:03.922Z" + "'", str27, "2020-11-25T01:49:03.922Z");
org.junit.Assert.assertNotNull(property30);
org.junit.Assert.assertNotNull(property31);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 7 + "'", int32 == 7);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(dateTimeField34);
org.junit.Assert.assertTrue("'" + int36 + "' != '" + 3 + "'", int36 == 3);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 7 + "'", int37 == 7);
org.junit.Assert.assertNotNull(instant38);
}
@Test
@Ignore
public void test1620() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1620");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
int int4 = mutableDateTime2.getSecondOfDay();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 6544 + "'", int4 == 6544);
}
@Test
@Ignore
public void test1621() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1621");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
mutableDateTime9.addDays(19);
int int19 = mutableDateTime9.getCenturyOfEra();
int int20 = mutableDateTime9.getYearOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:04.041Z" + "'", str4, "2020-11-25T01:49:04.041Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:04.041Z" + "'", str11, "2020-11-25T01:49:04.041Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:04.041Z" + "'", str15, "2020-11-25T01:49:04.041Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 20 + "'", int19 == 20);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 2020 + "'", int20 == 2020);
}
@Test
@Ignore
public void test1622() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1622");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
mutableDateTime2.setTime((int) (short) 10, (int) '#', 49, (int) (byte) 10);
mutableDateTime2.addDays((int) '4');
org.joda.time.MutableDateTime.Property property13 = mutableDateTime2.dayOfWeek();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.hourOfDay();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime16.dayOfWeek();
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
mutableDateTime25.setTime((long) '#');
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
org.joda.time.ReadablePeriod readablePeriod35 = null;
mutableDateTime32.add(readablePeriod35);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime32.hourOfDay();
java.lang.String str38 = mutableDateTime32.toString();
int int39 = mutableDateTime25.compareTo((org.joda.time.ReadableInstant) mutableDateTime32);
java.lang.Object obj40 = mutableDateTime25.clone();
long long41 = mutableDateTime25.getMillis();
java.lang.Object obj42 = null;
org.joda.time.Chronology chronology43 = null;
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(obj42, chronology43);
org.joda.time.format.DateTimeFormatter dateTimeFormatter45 = null;
java.lang.String str46 = mutableDateTime44.toString(dateTimeFormatter45);
org.joda.time.ReadablePeriod readablePeriod47 = null;
mutableDateTime44.add(readablePeriod47);
org.joda.time.MutableDateTime.Property property49 = mutableDateTime44.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType50 = property49.getFieldType();
int int51 = mutableDateTime25.get(dateTimeFieldType50);
boolean boolean52 = property22.equals((java.lang.Object) mutableDateTime25);
java.util.Locale locale53 = null;
int int54 = property22.getMaximumTextLength(locale53);
org.joda.time.DateTimeField dateTimeField55 = property22.getField();
int int56 = mutableDateTime2.get(dateTimeField55);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property13);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:04.068Z" + "'", str18, "2020-11-25T01:49:04.068Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:04.068Z" + "'", str27, "2020-11-25T01:49:04.068Z");
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:04.068Z" + "'", str34, "2020-11-25T01:49:04.068Z");
org.junit.Assert.assertNotNull(property37);
// flaky: org.junit.Assert.assertEquals("'" + str38 + "' != '" + "2020-11-25T01:49:04.068Z" + "'", str38, "2020-11-25T01:49:04.068Z");
org.junit.Assert.assertTrue("'" + int39 + "' != '" + (-1) + "'", int39 == (-1));
org.junit.Assert.assertNotNull(obj40);
org.junit.Assert.assertEquals(obj40.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj40), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj40), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long41 + "' != '" + 1606262400035L + "'", long41 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str46 + "' != '" + "2020-11-25T01:49:04.068Z" + "'", str46, "2020-11-25T01:49:04.068Z");
org.junit.Assert.assertNotNull(property49);
org.junit.Assert.assertNotNull(dateTimeFieldType50);
org.junit.Assert.assertTrue("'" + int51 + "' != '" + 0 + "'", int51 == 0);
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + false + "'", boolean52 == false);
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 9 + "'", int54 == 9);
org.junit.Assert.assertNotNull(dateTimeField55);
org.junit.Assert.assertTrue("'" + int56 + "' != '" + 6 + "'", int56 == 6);
}
@Test
@Ignore
public void test1623() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1623");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.millisOfSecond();
int int13 = mutableDateTime2.getMonthOfYear();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:04.129Z" + "'", str4, "2020-11-25T01:49:04.129Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 11 + "'", int13 == 11);
}
@Test
public void test1624() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1624");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
org.joda.time.DurationField durationField3 = property2.getLeapDurationField();
int int4 = property2.getMinimumValue();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNull(durationField3);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
}
@Test
@Ignore
public void test1625() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1625");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.MutableDateTime mutableDateTime8 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime8.millisOfSecond();
mutableDateTime8.addHours(0);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:04.225Z" + "'", str4, "2020-11-25T01:49:04.225Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(property9);
}
@Test
@Ignore
public void test1626() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1626");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property3.add((long) (short) -1);
java.util.Locale locale6 = null;
int int7 = property3.getMaximumShortTextLength(locale6);
long long8 = property3.remainder();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.Instant instant12 = mutableDateTime11.toInstant();
mutableDateTime11.setSecondOfDay((int) '#');
mutableDateTime11.setTime((int) (short) 10, (int) '#', 49, (int) (byte) 10);
int int20 = mutableDateTime11.getMillisOfSecond();
int int21 = property3.compareTo((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.MutableDateTime mutableDateTime22 = property3.roundCeiling();
mutableDateTime22.addSeconds(6291);
int int25 = mutableDateTime22.getWeekOfWeekyear();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime22.secondOfMinute();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 3 + "'", int7 == 3);
org.junit.Assert.assertTrue("'" + long8 + "' != '" + 1L + "'", long8 == 1L);
org.junit.Assert.assertNotNull(instant12);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 10 + "'", int20 == 10);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 1 + "'", int21 == 1);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 1 + "'", int25 == 1);
org.junit.Assert.assertNotNull(property26);
}
@Test
@Ignore
public void test1627() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1627");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
int int8 = property7.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
org.joda.time.DurationField durationField10 = property7.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime11 = property7.roundHalfFloor();
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology13);
mutableDateTime14.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property17 = mutableDateTime14.minuteOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime14.year();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.hourOfDay();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
int int28 = property27.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime30 = property27.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime31 = property27.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod32 = null;
mutableDateTime31.add(readablePeriod32, 40);
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
int int40 = mutableDateTime37.getYearOfCentury();
org.joda.time.Chronology chronology41 = mutableDateTime37.getChronology();
org.joda.time.MutableDateTime mutableDateTime42 = mutableDateTime31.toMutableDateTime(chronology41);
mutableDateTime14.setChronology(chronology41);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(chronology41);
org.joda.time.DateTime dateTime45 = mutableDateTime11.toDateTime(chronology41);
int int46 = mutableDateTime11.getWeekyear();
mutableDateTime11.addMillis(1);
org.joda.time.ReadableDuration readableDuration49 = null;
mutableDateTime11.add(readableDuration49, 815);
org.joda.time.DateTime dateTime52 = mutableDateTime11.toDateTimeISO();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:04.308Z" + "'", str4, "2020-11-25T01:49:04.308Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:04.308Z" + "'", str23, "2020-11-25T01:49:04.308Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 7 + "'", int28 == 7);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime31);
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:04.308Z" + "'", str39, "2020-11-25T01:49:04.308Z");
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 20 + "'", int40 == 20);
org.junit.Assert.assertNotNull(chronology41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime45);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 2020 + "'", int46 == 2020);
org.junit.Assert.assertNotNull(dateTime52);
}
@Test
@Ignore
public void test1628() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1628");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfMonth();
boolean boolean4 = mutableDateTime1.isBefore((long) 9);
org.joda.time.Chronology chronology5 = mutableDateTime1.getChronology();
org.joda.time.MutableDateTime mutableDateTime6 = org.joda.time.MutableDateTime.now(chronology5);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(6335532L, chronology5);
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime10.dayOfWeek();
int int17 = property16.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime19 = property16.addWrapField(0);
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.DateTimeZone dateTimeZone23 = mutableDateTime22.getZone();
mutableDateTime22.setMinuteOfDay(4);
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.format.DateTimeFormatter dateTimeFormatter29 = null;
java.lang.String str30 = mutableDateTime28.toString(dateTimeFormatter29);
int int31 = mutableDateTime28.getYearOfCentury();
org.joda.time.Chronology chronology32 = mutableDateTime28.getChronology();
int int33 = mutableDateTime28.getWeekOfWeekyear();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
org.joda.time.DateTimeZone dateTimeZone37 = mutableDateTime36.getZone();
org.joda.time.DateTime dateTime38 = mutableDateTime28.toDateTime(dateTimeZone37);
org.joda.time.MutableDateTime mutableDateTime39 = mutableDateTime22.toMutableDateTime(dateTimeZone37);
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime(dateTimeZone37);
org.joda.time.DateTime dateTime41 = mutableDateTime19.toDateTime(dateTimeZone37);
java.lang.String str42 = mutableDateTime19.toString();
boolean boolean43 = mutableDateTime7.isBefore((org.joda.time.ReadableInstant) mutableDateTime19);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
org.junit.Assert.assertNotNull(chronology5);
org.junit.Assert.assertNotNull(mutableDateTime6);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:04.354Z" + "'", str12, "2020-11-25T01:49:04.354Z");
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 7 + "'", int17 == 7);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(dateTimeZone23);
// flaky: org.junit.Assert.assertEquals("'" + str30 + "' != '" + "2020-11-25T01:49:04.354Z" + "'", str30, "2020-11-25T01:49:04.354Z");
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 20 + "'", int31 == 20);
org.junit.Assert.assertNotNull(chronology32);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 48 + "'", int33 == 48);
org.junit.Assert.assertNotNull(dateTimeZone37);
org.junit.Assert.assertNotNull(dateTime38);
org.junit.Assert.assertNotNull(mutableDateTime39);
org.junit.Assert.assertNotNull(dateTime41);
// flaky: org.junit.Assert.assertEquals("'" + str42 + "' != '" + "2020-11-25T01:49:04.354Z" + "'", str42, "2020-11-25T01:49:04.354Z");
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + true + "'", boolean43 == true);
}
@Test
@Ignore
public void test1629() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1629");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
int int33 = property2.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime34 = property2.roundHalfFloor();
mutableDateTime34.addMillis(2189);
boolean boolean37 = mutableDateTime34.isAfterNow();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:04.415Z" + "'", str13, "2020-11-25T01:49:04.415Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:04.416Z" + "'", str27, "2020-11-25T01:49:04.416Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 1 + "'", int33 == 1);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
}
@Test
public void test1630() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1630");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime5.millisOfSecond();
mutableDateTime5.add(0L);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime5.weekyear();
org.joda.time.Interval interval10 = property9.toInterval();
java.util.Locale locale11 = null;
int int12 = property9.getMaximumShortTextLength(locale11);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(interval10);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 9 + "'", int12 == 9);
}
@Test
@Ignore
public void test1631() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1631");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
java.util.GregorianCalendar gregorianCalendar6 = mutableDateTime2.toGregorianCalendar();
boolean boolean7 = mutableDateTime2.isBeforeNow();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime10.dayOfWeek();
org.joda.time.MutableDateTime.Property property17 = mutableDateTime10.secondOfDay();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
mutableDateTime20.setMillisOfSecond(7);
java.util.Locale locale26 = null;
java.util.Calendar calendar27 = mutableDateTime20.toCalendar(locale26);
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.Instant instant31 = mutableDateTime30.toInstant();
org.joda.time.MutableDateTime.Property property32 = mutableDateTime30.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime33 = property32.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime34 = mutableDateTime33.toMutableDateTime();
org.joda.time.MutableDateTime.Property property35 = mutableDateTime33.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime37 = property35.set(49);
org.joda.time.DurationField durationField38 = property35.getDurationField();
org.joda.time.DateTimeField dateTimeField39 = property35.getField();
int int40 = mutableDateTime20.get(dateTimeField39);
mutableDateTime10.setRounding(dateTimeField39);
int int42 = mutableDateTime2.get(dateTimeField39);
mutableDateTime2.addWeeks(6428043);
int int45 = mutableDateTime2.getWeekOfWeekyear();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(gregorianCalendar6);
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:04.500Z" + "'", str12, "2020-11-25T01:49:04.500Z");
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:04.500Z" + "'", str22, "2020-11-25T01:49:04.500Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(calendar27);
// flaky: org.junit.Assert.assertEquals(calendar27.toString(), "java.util.GregorianCalendar[time=1606268944007,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=25,DAY_OF_YEAR=330,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=1,HOUR_OF_DAY=1,MINUTE=49,SECOND=4,MILLISECOND=7,ZONE_OFFSET=0,DST_OFFSET=0]");
org.junit.Assert.assertNotNull(instant31);
org.junit.Assert.assertNotNull(property32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(mutableDateTime37);
org.junit.Assert.assertNotNull(durationField38);
org.junit.Assert.assertNotNull(dateTimeField39);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 20 + "'", int40 == 20);
org.junit.Assert.assertTrue("'" + int42 + "' != '" + 20 + "'", int42 == 20);
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 31 + "'", int45 == 31);
}
@Test
public void test1632() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1632");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime2.add(readablePeriod6);
int int8 = mutableDateTime2.getDayOfWeek();
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfYear();
int int13 = mutableDateTime11.getSecondOfMinute();
boolean boolean14 = mutableDateTime2.equals((java.lang.Object) int13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime2.add(readablePeriod15, 51);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.secondOfDay();
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 4 + "'", int8 == 4);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 0 + "'", int13 == 0);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property18);
}
@Test
public void test1633() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1633");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = mutableDateTime2.copy();
org.joda.time.MutableDateTime mutableDateTime5 = mutableDateTime4.toMutableDateTimeISO();
mutableDateTime5.setTime((long) 4);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime5.yearOfEra();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(property8);
}
@Test
@Ignore
public void test1634() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1634");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.yearOfCentury();
int int10 = mutableDateTime2.getRoundingMode();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 0 + "'", int10 == 0);
}
@Test
@Ignore
public void test1635() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1635");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime13.add(readablePeriod14, 40);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime13.toMutableDateTime(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 100, chronology23);
mutableDateTime25.addYears(2);
org.joda.time.DateTimeZone dateTimeZone28 = mutableDateTime25.getZone();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:04.641Z" + "'", str5, "2020-11-25T01:49:04.641Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:04.641Z" + "'", str21, "2020-11-25T01:49:04.641Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(dateTimeZone28);
}
@Test
@Ignore
public void test1636() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1636");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
boolean boolean24 = mutableDateTime23.isBeforeNow();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime23.dayOfMonth();
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.format.DateTimeFormatter dateTimeFormatter29 = null;
java.lang.String str30 = mutableDateTime28.toString(dateTimeFormatter29);
int int31 = mutableDateTime28.getYearOfCentury();
org.joda.time.Chronology chronology32 = mutableDateTime28.getChronology();
int int33 = mutableDateTime28.getWeekOfWeekyear();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
org.joda.time.DateTimeZone dateTimeZone37 = mutableDateTime36.getZone();
org.joda.time.DateTime dateTime38 = mutableDateTime28.toDateTime(dateTimeZone37);
org.joda.time.MutableDateTime mutableDateTime39 = mutableDateTime28.copy();
boolean boolean40 = mutableDateTime28.isAfterNow();
org.joda.time.MutableDateTime.Property property41 = mutableDateTime28.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime43 = property41.add(2189);
java.lang.Object obj44 = null;
org.joda.time.Chronology chronology45 = null;
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime(obj44, chronology45);
org.joda.time.format.DateTimeFormatter dateTimeFormatter47 = null;
java.lang.String str48 = mutableDateTime46.toString(dateTimeFormatter47);
org.joda.time.ReadablePeriod readablePeriod49 = null;
mutableDateTime46.add(readablePeriod49);
org.joda.time.MutableDateTime.Property property51 = mutableDateTime46.hourOfDay();
org.joda.time.MutableDateTime.Property property52 = mutableDateTime46.dayOfWeek();
org.joda.time.DurationField durationField53 = property52.getRangeDurationField();
java.lang.String str54 = property52.getName();
org.joda.time.DateTimeFieldType dateTimeFieldType55 = property52.getFieldType();
boolean boolean56 = mutableDateTime43.isSupported(dateTimeFieldType55);
// The following exception was thrown during execution in test generation
try {
mutableDateTime23.set(dateTimeFieldType55, 981);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 981 for dayOfWeek must be in the range [1,7]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:04.674Z" + "'", str4, "2020-11-25T01:49:04.674Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:04.674Z" + "'", str20, "2020-11-25T01:49:04.674Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + true + "'", boolean24 == true);
org.junit.Assert.assertNotNull(property25);
// flaky: org.junit.Assert.assertEquals("'" + str30 + "' != '" + "2020-11-25T01:49:04.674Z" + "'", str30, "2020-11-25T01:49:04.674Z");
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 20 + "'", int31 == 20);
org.junit.Assert.assertNotNull(chronology32);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 48 + "'", int33 == 48);
org.junit.Assert.assertNotNull(dateTimeZone37);
org.junit.Assert.assertNotNull(dateTime38);
org.junit.Assert.assertNotNull(mutableDateTime39);
org.junit.Assert.assertTrue("'" + boolean40 + "' != '" + false + "'", boolean40 == false);
org.junit.Assert.assertNotNull(property41);
org.junit.Assert.assertNotNull(mutableDateTime43);
// flaky: org.junit.Assert.assertEquals("'" + str48 + "' != '" + "2020-11-25T01:49:04.674Z" + "'", str48, "2020-11-25T01:49:04.674Z");
org.junit.Assert.assertNotNull(property51);
org.junit.Assert.assertNotNull(property52);
org.junit.Assert.assertNotNull(durationField53);
org.junit.Assert.assertEquals("'" + str54 + "' != '" + "dayOfWeek" + "'", str54, "dayOfWeek");
org.junit.Assert.assertNotNull(dateTimeFieldType55);
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + true + "'", boolean56 == true);
}
@Test
public void test1637() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1637");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) 10597);
}
@Test
public void test1638() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1638");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.secondOfMinute();
int int8 = property7.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.secondOfMinute();
org.joda.time.MutableDateTime mutableDateTime11 = mutableDateTime9.copy();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 59 + "'", int8 == 59);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
@Test
public void test1639() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1639");
org.joda.time.DateTimeZone dateTimeZone1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) 6534, dateTimeZone1);
}
@Test
public void test1640() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1640");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.secondOfMinute();
int int8 = mutableDateTime2.getYearOfCentury();
int int9 = mutableDateTime2.getEra();
int int10 = mutableDateTime2.getMinuteOfHour();
int int11 = mutableDateTime2.getRoundingMode();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 21 + "'", int8 == 21);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 1 + "'", int9 == 1);
// flaky: org.junit.Assert.assertTrue("'" + int10 + "' != '" + 49 + "'", int10 == 49);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 0 + "'", int11 == 0);
}
@Test
public void test1641() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1641");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
java.util.Date date8 = mutableDateTime2.toDate();
mutableDateTime2.setMillisOfDay(0);
boolean boolean12 = mutableDateTime2.isBefore(1580521636005L);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:04.832Z" + "'", str4, "2020-11-25T01:49:04.832Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(date8);
// flaky: org.junit.Assert.assertEquals(date8.toString(), "Wed Nov 25 01:49:04 UTC 2020");
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
}
@Test
@Ignore
public void test1642() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1642");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
int int5 = mutableDateTime2.getYearOfEra();
mutableDateTime2.addWeeks(17);
mutableDateTime2.addMinutes(2);
org.joda.time.MutableDateTime mutableDateTime10 = mutableDateTime2.toMutableDateTime();
org.joda.time.DateTimeField dateTimeField11 = mutableDateTime2.getRoundingField();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 2020 + "'", int5 == 2020);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNull(dateTimeField11);
}
@Test
@Ignore
public void test1643() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1643");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
int int9 = mutableDateTime2.getRoundingMode();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.hourOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime12.dayOfWeek();
int int19 = property18.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime22 = property18.roundHalfEven();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.minuteOfHour();
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.format.DateTimeFormatter dateTimeFormatter27 = null;
java.lang.String str28 = mutableDateTime26.toString(dateTimeFormatter27);
org.joda.time.DateTimeField dateTimeField29 = mutableDateTime26.getRoundingField();
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology31);
mutableDateTime32.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property35 = mutableDateTime32.minuteOfDay();
org.joda.time.MutableDateTime.Property property36 = mutableDateTime32.year();
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
org.joda.time.format.DateTimeFormatter dateTimeFormatter40 = null;
java.lang.String str41 = mutableDateTime39.toString(dateTimeFormatter40);
org.joda.time.ReadablePeriod readablePeriod42 = null;
mutableDateTime39.add(readablePeriod42);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime39.hourOfDay();
org.joda.time.MutableDateTime.Property property45 = mutableDateTime39.dayOfWeek();
int int46 = property45.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime48 = property45.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime49 = property45.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod50 = null;
mutableDateTime49.add(readablePeriod50, 40);
java.lang.Object obj53 = null;
org.joda.time.Chronology chronology54 = null;
org.joda.time.MutableDateTime mutableDateTime55 = new org.joda.time.MutableDateTime(obj53, chronology54);
org.joda.time.format.DateTimeFormatter dateTimeFormatter56 = null;
java.lang.String str57 = mutableDateTime55.toString(dateTimeFormatter56);
int int58 = mutableDateTime55.getYearOfCentury();
org.joda.time.Chronology chronology59 = mutableDateTime55.getChronology();
org.joda.time.MutableDateTime mutableDateTime60 = mutableDateTime49.toMutableDateTime(chronology59);
mutableDateTime32.setChronology(chronology59);
mutableDateTime26.setChronology(chronology59);
org.joda.time.MutableDateTime mutableDateTime63 = mutableDateTime22.toMutableDateTime(chronology59);
int int64 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime22);
org.joda.time.MutableDateTime.Property property65 = mutableDateTime22.minuteOfDay();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:04.948Z" + "'", str14, "2020-11-25T01:49:04.948Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 7 + "'", int19 == 7);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(property23);
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:04.948Z" + "'", str28, "2020-11-25T01:49:04.948Z");
org.junit.Assert.assertNull(dateTimeField29);
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(property36);
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:04.948Z" + "'", str41, "2020-11-25T01:49:04.948Z");
org.junit.Assert.assertNotNull(property44);
org.junit.Assert.assertNotNull(property45);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 7 + "'", int46 == 7);
org.junit.Assert.assertNotNull(mutableDateTime48);
org.junit.Assert.assertNotNull(mutableDateTime49);
// flaky: org.junit.Assert.assertEquals("'" + str57 + "' != '" + "2020-11-25T01:49:04.948Z" + "'", str57, "2020-11-25T01:49:04.948Z");
org.junit.Assert.assertTrue("'" + int58 + "' != '" + 20 + "'", int58 == 20);
org.junit.Assert.assertNotNull(chronology59);
org.junit.Assert.assertNotNull(mutableDateTime60);
org.junit.Assert.assertNotNull(mutableDateTime63);
org.junit.Assert.assertTrue("'" + int64 + "' != '" + (-1) + "'", int64 == (-1));
org.junit.Assert.assertNotNull(property65);
}
@Test
public void test1644() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1644");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.setMonthOfYear((int) (byte) 10);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
java.lang.Object obj8 = mutableDateTime2.clone();
java.lang.Class<?> wildcardClass9 = mutableDateTime2.getClass();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(obj8);
// flaky: org.junit.Assert.assertEquals(obj8.toString(), "2020-10-25T01:49:05.006Z");
// flaky: org.junit.Assert.assertEquals(java.lang.String.valueOf(obj8), "2020-10-25T01:49:05.006Z");
// flaky: org.junit.Assert.assertEquals(java.util.Objects.toString(obj8), "2020-10-25T01:49:05.006Z");
org.junit.Assert.assertNotNull(wildcardClass9);
}
@Test
@Ignore
public void test1645() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1645");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime6.dayOfWeek();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
mutableDateTime10.addSeconds((int) (byte) 0);
int int14 = mutableDateTime10.getSecondOfMinute();
mutableDateTime10.setWeekyear(20);
mutableDateTime6.setMillis((org.joda.time.ReadableInstant) mutableDateTime10);
int int18 = mutableDateTime6.getMinuteOfDay();
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime6.toMutableDateTimeISO();
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology22);
mutableDateTime23.setSecondOfMinute((int) '4');
int int26 = mutableDateTime23.getMinuteOfDay();
int int27 = mutableDateTime23.getCenturyOfEra();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
int int31 = mutableDateTime30.getDayOfWeek();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.DateTimeZone dateTimeZone35 = mutableDateTime34.getZone();
org.joda.time.MutableDateTime mutableDateTime36 = org.joda.time.MutableDateTime.now(dateTimeZone35);
mutableDateTime30.setZoneRetainFields(dateTimeZone35);
org.joda.time.DateTime dateTime38 = mutableDateTime23.toDateTime(dateTimeZone35);
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(259200010L, dateTimeZone35);
org.joda.time.MutableDateTime.Property property40 = mutableDateTime39.dayOfYear();
int int41 = mutableDateTime39.getDayOfWeek();
org.joda.time.MutableDateTime mutableDateTime42 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property43 = mutableDateTime42.dayOfMonth();
int int44 = mutableDateTime42.getCenturyOfEra();
org.joda.time.Chronology chronology46 = null;
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology46);
mutableDateTime47.setSecondOfMinute((int) '4');
int int50 = mutableDateTime47.getMinuteOfDay();
int int51 = mutableDateTime47.getCenturyOfEra();
java.lang.Object obj52 = null;
org.joda.time.Chronology chronology53 = null;
org.joda.time.MutableDateTime mutableDateTime54 = new org.joda.time.MutableDateTime(obj52, chronology53);
int int55 = mutableDateTime54.getDayOfWeek();
java.lang.Object obj56 = null;
org.joda.time.Chronology chronology57 = null;
org.joda.time.MutableDateTime mutableDateTime58 = new org.joda.time.MutableDateTime(obj56, chronology57);
org.joda.time.DateTimeZone dateTimeZone59 = mutableDateTime58.getZone();
org.joda.time.MutableDateTime mutableDateTime60 = org.joda.time.MutableDateTime.now(dateTimeZone59);
mutableDateTime54.setZoneRetainFields(dateTimeZone59);
org.joda.time.DateTime dateTime62 = mutableDateTime47.toDateTime(dateTimeZone59);
mutableDateTime42.setZoneRetainFields(dateTimeZone59);
org.joda.time.MutableDateTime mutableDateTime64 = new org.joda.time.MutableDateTime(dateTimeZone59);
org.joda.time.DateTime dateTime65 = mutableDateTime39.toDateTime(dateTimeZone59);
mutableDateTime6.setZoneRetainFields(dateTimeZone59);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int14 + "' != '" + 5 + "'", int14 == 5);
// flaky: org.junit.Assert.assertTrue("'" + int18 + "' != '" + 109 + "'", int18 == 109);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 0 + "'", int26 == 0);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 19 + "'", int27 == 19);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 3 + "'", int31 == 3);
org.junit.Assert.assertNotNull(dateTimeZone35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertNotNull(dateTime38);
org.junit.Assert.assertNotNull(property40);
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 7 + "'", int41 == 7);
org.junit.Assert.assertNotNull(property43);
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 20 + "'", int44 == 20);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 0 + "'", int50 == 0);
org.junit.Assert.assertTrue("'" + int51 + "' != '" + 19 + "'", int51 == 19);
org.junit.Assert.assertTrue("'" + int55 + "' != '" + 3 + "'", int55 == 3);
org.junit.Assert.assertNotNull(dateTimeZone59);
org.junit.Assert.assertNotNull(mutableDateTime60);
org.junit.Assert.assertNotNull(dateTime62);
org.junit.Assert.assertNotNull(dateTime65);
}
@Test
@Ignore
public void test1646() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1646");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
org.joda.time.DateTimeFieldType dateTimeFieldType6 = property5.getFieldType();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
int int10 = mutableDateTime9.getDayOfWeek();
mutableDateTime9.addSeconds((int) (byte) 0);
mutableDateTime9.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime9);
mutableDateTime9.addYears(1);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime9.minuteOfDay();
int int19 = property5.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime9.centuryOfEra();
org.joda.time.Interval interval21 = property20.toInterval();
org.joda.time.MutableDateTime mutableDateTime22 = property20.roundFloor();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(dateTimeFieldType6);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 3 + "'", int10 == 3);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + (-1) + "'", int19 == (-1));
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertNotNull(interval21);
org.junit.Assert.assertNotNull(mutableDateTime22);
}
@Test
@Ignore
public void test1647() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1647");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = mutableDateTime2.copy();
org.joda.time.MutableDateTime mutableDateTime5 = mutableDateTime4.toMutableDateTimeISO();
org.joda.time.DateTime dateTime6 = mutableDateTime4.toDateTimeISO();
java.util.Locale locale7 = null;
java.util.Calendar calendar8 = dateTime6.toCalendar(locale7);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(dateTime6);
org.junit.Assert.assertNotNull(calendar8);
org.junit.Assert.assertEquals(calendar8.toString(), "java.util.GregorianCalendar[time=1,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=1970,MONTH=0,WEEK_OF_YEAR=1,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=1,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=0,HOUR_OF_DAY=0,MINUTE=0,SECOND=0,MILLISECOND=1,ZONE_OFFSET=0,DST_OFFSET=0]");
}
@Test
@Ignore
public void test1648() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1648");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
org.joda.time.MutableDateTime mutableDateTime24 = org.joda.time.MutableDateTime.now(chronology22);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfYear();
boolean boolean26 = mutableDateTime24.isEqualNow();
java.util.Locale locale27 = null;
java.util.Calendar calendar28 = mutableDateTime24.toCalendar(locale27);
long long29 = mutableDateTime24.getMillis();
org.joda.time.MutableDateTime.Property property30 = mutableDateTime24.monthOfYear();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.245Z" + "'", str4, "2020-11-25T01:49:05.245Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:05.245Z" + "'", str20, "2020-11-25T01:49:05.245Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + true + "'", boolean26 == true);
org.junit.Assert.assertNotNull(calendar28);
// flaky: org.junit.Assert.assertEquals(calendar28.toString(), "java.util.GregorianCalendar[time=1606268945245,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=25,DAY_OF_YEAR=330,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=1,HOUR_OF_DAY=1,MINUTE=49,SECOND=5,MILLISECOND=245,ZONE_OFFSET=0,DST_OFFSET=0]");
// flaky: org.junit.Assert.assertTrue("'" + long29 + "' != '" + 1606268945245L + "'", long29 == 1606268945245L);
org.junit.Assert.assertNotNull(property30);
}
@Test
@Ignore
public void test1649() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1649");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime13.getZone();
org.joda.time.DurationFieldType durationFieldType16 = null;
// The following exception was thrown during execution in test generation
try {
mutableDateTime13.add(durationFieldType16, 28821);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Field must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.289Z" + "'", str4, "2020-11-25T01:49:05.289Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
org.junit.Assert.assertNotNull(dateTimeZone15);
}
@Test
@Ignore
public void test1650() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1650");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.yearOfCentury();
java.util.Locale locale10 = null;
int int11 = property9.getMaximumTextLength(locale10);
java.util.Locale locale12 = null;
java.lang.String str13 = property9.getAsShortText(locale12);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 2 + "'", int11 == 2);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "20" + "'", str13, "20");
}
@Test
@Ignore
public void test1651() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1651");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
mutableDateTime14.setMinuteOfDay(4);
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
org.joda.time.Chronology chronology24 = mutableDateTime20.getChronology();
int int25 = mutableDateTime20.getWeekOfWeekyear();
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.DateTimeZone dateTimeZone29 = mutableDateTime28.getZone();
org.joda.time.DateTime dateTime30 = mutableDateTime20.toDateTime(dateTimeZone29);
org.joda.time.MutableDateTime mutableDateTime31 = mutableDateTime14.toMutableDateTime(dateTimeZone29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(dateTimeZone29);
org.joda.time.DateTime dateTime33 = mutableDateTime11.toDateTime(dateTimeZone29);
org.joda.time.DateTime dateTime34 = mutableDateTime11.toDateTimeISO();
// The following exception was thrown during execution in test generation
try {
mutableDateTime11.setMillisOfSecond(46004);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 46004 for millisOfSecond must be in the range [0,999]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.370Z" + "'", str4, "2020-11-25T01:49:05.370Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(dateTimeZone15);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:05.370Z" + "'", str22, "2020-11-25T01:49:05.370Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(chronology24);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 48 + "'", int25 == 48);
org.junit.Assert.assertNotNull(dateTimeZone29);
org.junit.Assert.assertNotNull(dateTime30);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(dateTime33);
org.junit.Assert.assertNotNull(dateTime34);
}
@Test
@Ignore
public void test1652() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1652");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
int int10 = mutableDateTime2.getWeekOfWeekyear();
mutableDateTime2.addYears((-1));
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime2.add(readablePeriod13);
int int15 = mutableDateTime2.getRoundingMode();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.413Z" + "'", str4, "2020-11-25T01:49:05.413Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 48 + "'", int10 == 48);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
}
@Test
@Ignore
public void test1653() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1653");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.DateTimeField dateTimeField5 = mutableDateTime2.getRoundingField();
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology7);
mutableDateTime8.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property11 = mutableDateTime8.minuteOfDay();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime8.year();
java.lang.Object obj13 = null;
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime(obj13, chronology14);
org.joda.time.format.DateTimeFormatter dateTimeFormatter16 = null;
java.lang.String str17 = mutableDateTime15.toString(dateTimeFormatter16);
org.joda.time.ReadablePeriod readablePeriod18 = null;
mutableDateTime15.add(readablePeriod18);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime15.hourOfDay();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime15.dayOfWeek();
int int22 = property21.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime24 = property21.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime25 = property21.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod26 = null;
mutableDateTime25.add(readablePeriod26, 40);
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.format.DateTimeFormatter dateTimeFormatter32 = null;
java.lang.String str33 = mutableDateTime31.toString(dateTimeFormatter32);
int int34 = mutableDateTime31.getYearOfCentury();
org.joda.time.Chronology chronology35 = mutableDateTime31.getChronology();
org.joda.time.MutableDateTime mutableDateTime36 = mutableDateTime25.toMutableDateTime(chronology35);
mutableDateTime8.setChronology(chronology35);
mutableDateTime2.setChronology(chronology35);
org.joda.time.MutableDateTime mutableDateTime39 = mutableDateTime2.toMutableDateTimeISO();
org.joda.time.ReadableDuration readableDuration40 = null;
mutableDateTime39.add(readableDuration40, 6544);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.464Z" + "'", str4, "2020-11-25T01:49:05.464Z");
org.junit.Assert.assertNull(dateTimeField5);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property12);
// flaky: org.junit.Assert.assertEquals("'" + str17 + "' != '" + "2020-11-25T01:49:05.464Z" + "'", str17, "2020-11-25T01:49:05.464Z");
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 7 + "'", int22 == 7);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime25);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:49:05.465Z" + "'", str33, "2020-11-25T01:49:05.465Z");
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 20 + "'", int34 == 20);
org.junit.Assert.assertNotNull(chronology35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertNotNull(mutableDateTime39);
}
@Test
public void test1654() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1654");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = mutableDateTime2.copy();
mutableDateTime4.setWeekyear(1);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime4.yearOfEra();
java.util.Locale locale8 = null;
java.lang.String str9 = property7.getAsShortText(locale8);
boolean boolean10 = property7.isLeap();
boolean boolean12 = property7.equals((java.lang.Object) "2020-11-25T01:45:02.770Z");
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime((java.lang.Object) boolean12);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: No instant converter found for type: java.lang.Boolean");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertEquals("'" + str9 + "' != '" + "1" + "'", str9, "1");
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
}
@Test
public void test1655() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1655");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.util.Locale locale6 = null;
java.lang.String str7 = property5.getAsShortText(locale6);
java.util.Locale locale8 = null;
int int9 = property5.getMaximumTextLength(locale8);
java.lang.String str10 = property5.getName();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Jan" + "'", str7, "Jan");
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 9 + "'", int9 == 9);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "monthOfYear" + "'", str10, "monthOfYear");
}
@Test
@Ignore
public void test1656() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1656");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime2.add(readablePeriod7);
mutableDateTime2.setMonthOfYear((int) (byte) 1);
int int11 = mutableDateTime2.getMonthOfYear();
int int12 = mutableDateTime2.getDayOfYear();
org.joda.time.Chronology chronology13 = mutableDateTime2.getChronology();
mutableDateTime2.setMillis((-2484518399990L));
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.603Z" + "'", str4, "2020-11-25T01:49:05.603Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 1 + "'", int11 == 1);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 25 + "'", int12 == 25);
org.junit.Assert.assertNotNull(chronology13);
}
@Test
@Ignore
public void test1657() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1657");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
int int33 = property2.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime34 = property2.roundHalfFloor();
mutableDateTime34.addDays(2189);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime34.dayOfWeek();
int int38 = mutableDateTime34.getEra();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:05.644Z" + "'", str13, "2020-11-25T01:49:05.644Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:05.644Z" + "'", str27, "2020-11-25T01:49:05.644Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 1 + "'", int33 == 1);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertNotNull(property37);
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 1 + "'", int38 == 1);
}
@Test
@Ignore
public void test1658() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1658");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
int int33 = property2.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime34 = property2.roundHalfFloor();
mutableDateTime34.addDays(2189);
int int37 = mutableDateTime34.getDayOfWeek();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:05.707Z" + "'", str13, "2020-11-25T01:49:05.707Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:05.707Z" + "'", str27, "2020-11-25T01:49:05.707Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 1 + "'", int33 == 1);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 6 + "'", int37 == 6);
}
@Test
@Ignore
public void test1659() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1659");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime13 = property11.add((long) (short) -1);
mutableDateTime13.setWeekOfWeekyear((int) '4');
mutableDateTime7.setTime((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.secondOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.secondOfMinute();
boolean boolean20 = mutableDateTime13.isBefore((long) (short) 10);
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
mutableDateTime23.setTime((long) '#');
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
java.lang.String str36 = mutableDateTime30.toString();
int int37 = mutableDateTime23.compareTo((org.joda.time.ReadableInstant) mutableDateTime30);
org.joda.time.MutableDateTime mutableDateTime38 = mutableDateTime23.copy();
java.lang.Object obj39 = null;
org.joda.time.Chronology chronology40 = null;
org.joda.time.MutableDateTime mutableDateTime41 = new org.joda.time.MutableDateTime(obj39, chronology40);
org.joda.time.format.DateTimeFormatter dateTimeFormatter42 = null;
java.lang.String str43 = mutableDateTime41.toString(dateTimeFormatter42);
int int44 = mutableDateTime41.getYearOfCentury();
org.joda.time.Chronology chronology45 = mutableDateTime41.getChronology();
org.joda.time.MutableDateTime mutableDateTime46 = org.joda.time.MutableDateTime.now(chronology45);
org.joda.time.MutableDateTime mutableDateTime47 = mutableDateTime23.toMutableDateTime(chronology45);
java.lang.Object obj48 = null;
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime(obj48, chronology49);
org.joda.time.format.DateTimeFormatter dateTimeFormatter51 = null;
java.lang.String str52 = mutableDateTime50.toString(dateTimeFormatter51);
mutableDateTime50.setTime((long) '#');
java.lang.Object obj55 = null;
org.joda.time.Chronology chronology56 = null;
org.joda.time.MutableDateTime mutableDateTime57 = new org.joda.time.MutableDateTime(obj55, chronology56);
org.joda.time.format.DateTimeFormatter dateTimeFormatter58 = null;
java.lang.String str59 = mutableDateTime57.toString(dateTimeFormatter58);
org.joda.time.ReadablePeriod readablePeriod60 = null;
mutableDateTime57.add(readablePeriod60);
org.joda.time.MutableDateTime.Property property62 = mutableDateTime57.hourOfDay();
java.lang.String str63 = mutableDateTime57.toString();
int int64 = mutableDateTime50.compareTo((org.joda.time.ReadableInstant) mutableDateTime57);
org.joda.time.MutableDateTime mutableDateTime65 = mutableDateTime50.copy();
java.lang.Object obj66 = null;
org.joda.time.Chronology chronology67 = null;
org.joda.time.MutableDateTime mutableDateTime68 = new org.joda.time.MutableDateTime(obj66, chronology67);
org.joda.time.format.DateTimeFormatter dateTimeFormatter69 = null;
java.lang.String str70 = mutableDateTime68.toString(dateTimeFormatter69);
int int71 = mutableDateTime68.getYearOfCentury();
org.joda.time.Chronology chronology72 = mutableDateTime68.getChronology();
org.joda.time.MutableDateTime mutableDateTime73 = org.joda.time.MutableDateTime.now(chronology72);
org.joda.time.MutableDateTime mutableDateTime74 = mutableDateTime50.toMutableDateTime(chronology72);
org.joda.time.DateTime dateTime75 = mutableDateTime23.toDateTime(chronology72);
org.joda.time.DateTime dateTime76 = mutableDateTime13.toDateTime(chronology72);
int int77 = mutableDateTime13.getYearOfCentury();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str4, "2020-11-25T01:49:05.774Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str25, "2020-11-25T01:49:05.774Z");
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str32, "2020-11-25T01:49:05.774Z");
org.junit.Assert.assertNotNull(property35);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str36, "2020-11-25T01:49:05.774Z");
org.junit.Assert.assertTrue("'" + int37 + "' != '" + (-1) + "'", int37 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime38);
// flaky: org.junit.Assert.assertEquals("'" + str43 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str43, "2020-11-25T01:49:05.774Z");
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 20 + "'", int44 == 20);
org.junit.Assert.assertNotNull(chronology45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertNotNull(mutableDateTime47);
// flaky: org.junit.Assert.assertEquals("'" + str52 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str52, "2020-11-25T01:49:05.774Z");
// flaky: org.junit.Assert.assertEquals("'" + str59 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str59, "2020-11-25T01:49:05.774Z");
org.junit.Assert.assertNotNull(property62);
// flaky: org.junit.Assert.assertEquals("'" + str63 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str63, "2020-11-25T01:49:05.774Z");
org.junit.Assert.assertTrue("'" + int64 + "' != '" + (-1) + "'", int64 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime65);
// flaky: org.junit.Assert.assertEquals("'" + str70 + "' != '" + "2020-11-25T01:49:05.774Z" + "'", str70, "2020-11-25T01:49:05.774Z");
org.junit.Assert.assertTrue("'" + int71 + "' != '" + 20 + "'", int71 == 20);
org.junit.Assert.assertNotNull(chronology72);
org.junit.Assert.assertNotNull(mutableDateTime73);
org.junit.Assert.assertNotNull(mutableDateTime74);
org.junit.Assert.assertNotNull(dateTime75);
org.junit.Assert.assertNotNull(dateTime76);
org.junit.Assert.assertTrue("'" + int77 + "' != '" + 70 + "'", int77 == 70);
}
@Test
@Ignore
public void test1660() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1660");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.centuryOfEra();
org.joda.time.MutableDateTime mutableDateTime10 = property9.roundHalfFloor();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
mutableDateTime13.setTime((long) '#');
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
org.joda.time.ReadablePeriod readablePeriod23 = null;
mutableDateTime20.add(readablePeriod23);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime20.hourOfDay();
java.lang.String str26 = mutableDateTime20.toString();
int int27 = mutableDateTime13.compareTo((org.joda.time.ReadableInstant) mutableDateTime20);
java.lang.Object obj28 = mutableDateTime13.clone();
long long29 = mutableDateTime13.getMillis();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
org.joda.time.ReadablePeriod readablePeriod35 = null;
mutableDateTime32.add(readablePeriod35);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime32.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType38 = property37.getFieldType();
int int39 = mutableDateTime13.get(dateTimeFieldType38);
int int40 = mutableDateTime10.get(dateTimeFieldType38);
mutableDateTime10.addWeeks(6353);
mutableDateTime10.setDate((long) 47);
java.util.GregorianCalendar gregorianCalendar45 = mutableDateTime10.toGregorianCalendar();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:05.846Z" + "'", str4, "2020-11-25T01:49:05.846Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(mutableDateTime10);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:05.846Z" + "'", str15, "2020-11-25T01:49:05.846Z");
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:05.846Z" + "'", str22, "2020-11-25T01:49:05.846Z");
org.junit.Assert.assertNotNull(property25);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:05.846Z" + "'", str26, "2020-11-25T01:49:05.846Z");
org.junit.Assert.assertTrue("'" + int27 + "' != '" + (-1) + "'", int27 == (-1));
org.junit.Assert.assertNotNull(obj28);
org.junit.Assert.assertEquals(obj28.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj28), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj28), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long29 + "' != '" + 1606262400035L + "'", long29 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:05.846Z" + "'", str34, "2020-11-25T01:49:05.846Z");
org.junit.Assert.assertNotNull(property37);
org.junit.Assert.assertNotNull(dateTimeFieldType38);
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 0 + "'", int39 == 0);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 0 + "'", int40 == 0);
org.junit.Assert.assertNotNull(gregorianCalendar45);
}
@Test
@Ignore
public void test1661() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1661");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology5);
mutableDateTime6.setSecondOfMinute((int) '4');
int int9 = mutableDateTime6.getMinuteOfDay();
int int10 = mutableDateTime6.getCenturyOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
int int14 = mutableDateTime13.getDayOfWeek();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.MutableDateTime mutableDateTime19 = org.joda.time.MutableDateTime.now(dateTimeZone18);
mutableDateTime13.setZoneRetainFields(dateTimeZone18);
org.joda.time.DateTime dateTime21 = mutableDateTime6.toDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime22 = org.joda.time.MutableDateTime.now(dateTimeZone18);
long long23 = property2.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime22);
org.joda.time.MutableDateTime mutableDateTime24 = property2.getMutableDateTime();
org.joda.time.MutableDateTime mutableDateTime26 = property2.add((long) 9);
java.util.Locale locale27 = null;
int int28 = property2.getMaximumTextLength(locale27);
java.util.Locale locale29 = null;
java.lang.String str30 = property2.getAsText(locale29);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 19 + "'", int10 == 19);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 3 + "'", int14 == 3);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertTrue("'" + long23 + "' != '" + (-50L) + "'", long23 == (-50L));
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 9 + "'", int28 == 9);
org.junit.Assert.assertEquals("'" + str30 + "' != '" + "1979" + "'", str30, "1979");
}
@Test
@Ignore
public void test1662() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1662");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
org.joda.time.MutableDateTime mutableDateTime24 = org.joda.time.MutableDateTime.now(chronology22);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfYear();
org.joda.time.ReadableInstant readableInstant26 = null;
int int27 = property25.getDifference(readableInstant26);
int int28 = property25.getMaximumValueOverall();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.038Z" + "'", str4, "2020-11-25T01:49:06.038Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:06.038Z" + "'", str20, "2020-11-25T01:49:06.038Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 0 + "'", int27 == 0);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 366 + "'", int28 == 366);
}
@Test
public void test1663() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1663");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
mutableDateTime2.add((long) 3);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.monthOfYear();
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime2.toString(dateTimeFormatter13);
mutableDateTime2.addWeekyears((int) (short) 1);
mutableDateTime2.addMinutes(319);
org.joda.time.DateTimeZone dateTimeZone19 = mutableDateTime2.getZone();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.098Z" + "'", str4, "2020-11-25T01:49:06.098Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property12);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:06.101Z" + "'", str14, "2020-11-25T01:49:06.101Z");
org.junit.Assert.assertNotNull(dateTimeZone19);
}
@Test
public void test1664() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1664");
org.joda.time.MutableDateTime mutableDateTime1 = org.joda.time.MutableDateTime.parse("2020-11-25T01:45:40.213Z");
int int2 = mutableDateTime1.getMonthOfYear();
org.junit.Assert.assertNotNull(mutableDateTime1);
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 11 + "'", int2 == 11);
}
@Test
@Ignore
public void test1665() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1665");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
int int9 = property8.get();
java.util.Locale locale10 = null;
java.lang.String str11 = property8.getAsText(locale10);
java.util.Locale locale12 = null;
int int13 = property8.getMaximumTextLength(locale12);
java.lang.String str14 = property8.getAsString();
org.joda.time.Interval interval15 = property8.toInterval();
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology18);
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
org.joda.time.ReadablePeriod readablePeriod25 = null;
mutableDateTime22.add(readablePeriod25);
org.joda.time.MutableDateTime.Property property27 = mutableDateTime22.centuryOfEra();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
int int33 = mutableDateTime30.getYearOfCentury();
org.joda.time.Chronology chronology34 = mutableDateTime30.getChronology();
org.joda.time.MutableDateTime mutableDateTime35 = mutableDateTime22.toMutableDateTime(chronology34);
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime19, chronology34);
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(chronology34);
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime((long) 2, chronology34);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime((java.lang.Object) property8, chronology34);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: No instant converter found for type: org.joda.time.MutableDateTime$Property");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
// flaky: org.junit.Assert.assertTrue("'" + int9 + "' != '" + 168 + "'", int9 == 168);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "168" + "'", str11, "168");
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 3 + "'", int13 == 3);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "168" + "'", str14, "168");
org.junit.Assert.assertNotNull(interval15);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:06.168Z" + "'", str24, "2020-11-25T01:49:06.168Z");
org.junit.Assert.assertNotNull(property27);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:06.168Z" + "'", str32, "2020-11-25T01:49:06.168Z");
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 20 + "'", int33 == 20);
org.junit.Assert.assertNotNull(chronology34);
org.junit.Assert.assertNotNull(mutableDateTime35);
}
@Test
public void test1666() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1666");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
int int3 = mutableDateTime1.getMinuteOfHour();
int int4 = mutableDateTime1.getDayOfMonth();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime1.year();
org.joda.time.MutableDateTime mutableDateTime7 = property5.addWrapField(6319);
org.joda.time.MutableDateTime mutableDateTime8 = property5.roundFloor();
org.joda.time.MutableDateTime mutableDateTime9 = property5.roundCeiling();
int int10 = mutableDateTime9.getSecondOfDay();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 0 + "'", int10 == 0);
}
@Test
@Ignore
public void test1667() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1667");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.Instant instant14 = mutableDateTime13.toInstant();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime13.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime16 = property15.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime16.toMutableDateTime();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime16.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime19 = property18.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime19.copy();
boolean boolean21 = mutableDateTime2.isBefore((org.joda.time.ReadableInstant) mutableDateTime19);
java.util.Date date22 = mutableDateTime19.toDate();
// The following exception was thrown during execution in test generation
try {
java.lang.String str24 = mutableDateTime19.toString("2020-11-25T01:47:29.351Z");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal pattern component: T");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.264Z" + "'", str4, "2020-11-25T01:49:06.264Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(instant14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
org.junit.Assert.assertNotNull(date22);
org.junit.Assert.assertEquals(date22.toString(), "Fri Jan 01 00:00:00 UTC 2021");
}
@Test
@Ignore
public void test1668() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1668");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
java.lang.Object obj17 = mutableDateTime2.clone();
long long18 = mutableDateTime2.getMillis();
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
int int20 = mutableDateTime19.getWeekOfWeekyear();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime19.minuteOfHour();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.309Z" + "'", str4, "2020-11-25T01:49:06.309Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:06.309Z" + "'", str11, "2020-11-25T01:49:06.309Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:06.309Z" + "'", str15, "2020-11-25T01:49:06.309Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(obj17);
org.junit.Assert.assertEquals(obj17.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long18 + "' != '" + 1606262400035L + "'", long18 == 1606262400035L);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 48 + "'", int20 == 48);
org.junit.Assert.assertNotNull(property21);
}
@Test
@Ignore
public void test1669() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1669");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
int int8 = property7.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
org.joda.time.DurationField durationField10 = property7.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime11 = property7.roundHalfFloor();
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology13);
mutableDateTime14.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property17 = mutableDateTime14.minuteOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime14.year();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.hourOfDay();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
int int28 = property27.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime30 = property27.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime31 = property27.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod32 = null;
mutableDateTime31.add(readablePeriod32, 40);
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
int int40 = mutableDateTime37.getYearOfCentury();
org.joda.time.Chronology chronology41 = mutableDateTime37.getChronology();
org.joda.time.MutableDateTime mutableDateTime42 = mutableDateTime31.toMutableDateTime(chronology41);
mutableDateTime14.setChronology(chronology41);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(chronology41);
org.joda.time.DateTime dateTime45 = mutableDateTime11.toDateTime(chronology41);
int int46 = mutableDateTime11.getWeekyear();
mutableDateTime11.addMillis(1);
// The following exception was thrown during execution in test generation
try {
mutableDateTime11.setDayOfWeek(815);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 815 for dayOfWeek must be in the range [1,7]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.392Z" + "'", str4, "2020-11-25T01:49:06.392Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:06.392Z" + "'", str23, "2020-11-25T01:49:06.392Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 7 + "'", int28 == 7);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime31);
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:06.392Z" + "'", str39, "2020-11-25T01:49:06.392Z");
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 20 + "'", int40 == 20);
org.junit.Assert.assertNotNull(chronology41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime45);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 2020 + "'", int46 == 2020);
}
@Test
public void test1670() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1670");
org.joda.time.MutableDateTime mutableDateTime1 = org.joda.time.MutableDateTime.parse("2020-11-25T01:45:51.186Z");
org.junit.Assert.assertNotNull(mutableDateTime1);
}
@Test
@Ignore
public void test1671() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1671");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.ReadableInstant readableInstant8 = null;
mutableDateTime2.setDate(readableInstant8);
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.hourOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime12.dayOfWeek();
int int19 = property18.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime22 = property18.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod23 = null;
mutableDateTime22.add(readablePeriod23, 40);
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.format.DateTimeFormatter dateTimeFormatter29 = null;
java.lang.String str30 = mutableDateTime28.toString(dateTimeFormatter29);
int int31 = mutableDateTime28.getYearOfCentury();
org.joda.time.Chronology chronology32 = mutableDateTime28.getChronology();
org.joda.time.MutableDateTime mutableDateTime33 = mutableDateTime22.toMutableDateTime(chronology32);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(chronology32);
org.joda.time.MutableDateTime mutableDateTime35 = mutableDateTime2.toMutableDateTime(chronology32);
mutableDateTime35.add((long) 20);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.461Z" + "'", str4, "2020-11-25T01:49:06.461Z");
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:06.461Z" + "'", str14, "2020-11-25T01:49:06.461Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 7 + "'", int19 == 7);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str30 + "' != '" + "2020-11-25T01:49:06.461Z" + "'", str30, "2020-11-25T01:49:06.461Z");
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 20 + "'", int31 == 20);
org.junit.Assert.assertNotNull(chronology32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(mutableDateTime35);
}
@Test
public void test1672() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1672");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.DateTime dateTime2 = mutableDateTime1.toDateTimeISO();
org.joda.time.DateTimeField dateTimeField3 = mutableDateTime1.getRoundingField();
org.junit.Assert.assertNotNull(dateTime2);
org.junit.Assert.assertNull(dateTimeField3);
}
@Test
@Ignore
public void test1673() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1673");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
int int3 = mutableDateTime1.getMinuteOfHour();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime1.centuryOfEra();
mutableDateTime1.setMillisOfDay(0);
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.yearOfCentury();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime9.millisOfDay();
mutableDateTime9.add((long) 3);
mutableDateTime9.addWeekyears((int) (byte) 100);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime9.weekOfWeekyear();
boolean boolean23 = mutableDateTime9.isBefore((long) (byte) 1);
mutableDateTime1.setMillis((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now();
mutableDateTime25.setWeekOfWeekyear(48);
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.DateTimeZone dateTimeZone33 = mutableDateTime32.getZone();
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone33);
org.joda.time.MutableDateTime mutableDateTime35 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone33);
mutableDateTime35.setSecondOfMinute((int) (short) 0);
org.joda.time.ReadableDuration readableDuration38 = null;
mutableDateTime35.add(readableDuration38);
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property41 = mutableDateTime40.dayOfMonth();
boolean boolean43 = mutableDateTime40.isBefore((long) 9);
org.joda.time.Chronology chronology44 = mutableDateTime40.getChronology();
org.joda.time.MutableDateTime mutableDateTime45 = org.joda.time.MutableDateTime.now(chronology44);
mutableDateTime35.setChronology(chronology44);
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime25, chronology44);
mutableDateTime9.setChronology(chronology44);
int int49 = mutableDateTime9.getWeekOfWeekyear();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertNotNull(property4);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:06.523Z" + "'", str11, "2020-11-25T01:49:06.523Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(dateTimeZone33);
org.junit.Assert.assertNotNull(property41);
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + false + "'", boolean43 == false);
org.junit.Assert.assertNotNull(chronology44);
org.junit.Assert.assertNotNull(mutableDateTime45);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 48 + "'", int49 == 48);
}
@Test
public void test1674() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1674");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = property3.roundCeiling();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime4.minuteOfHour();
org.joda.time.MutableDateTime mutableDateTime7 = property5.addWrapField(56871817);
java.lang.String str8 = property5.getName();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "minuteOfHour" + "'", str8, "minuteOfHour");
}
@Test
@Ignore
public void test1675() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1675");
org.joda.time.DateTimeZone dateTimeZone0 = null;
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime(dateTimeZone0);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfYear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.Instant instant6 = mutableDateTime5.toInstant();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime8.toMutableDateTime();
mutableDateTime8.addHours(59);
java.lang.Object obj12 = mutableDateTime8.clone();
mutableDateTime1.setDate((org.joda.time.ReadableInstant) mutableDateTime8);
mutableDateTime8.setMinuteOfDay(993);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(instant6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(obj12);
org.junit.Assert.assertEquals(obj12.toString(), "2020-12-03T11:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj12), "2020-12-03T11:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj12), "2020-12-03T11:00:00.000Z");
}
@Test
@Ignore
public void test1676() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1676");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.Date date4 = mutableDateTime2.toDate();
int int5 = mutableDateTime2.getWeekyear();
java.lang.Object obj6 = null;
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime(obj6, chronology7);
org.joda.time.format.DateTimeFormatter dateTimeFormatter9 = null;
java.lang.String str10 = mutableDateTime8.toString(dateTimeFormatter9);
org.joda.time.ReadablePeriod readablePeriod11 = null;
mutableDateTime8.add(readablePeriod11);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime8.yearOfCentury();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime8.dayOfWeek();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime8.centuryOfEra();
org.joda.time.MutableDateTime mutableDateTime16 = property15.roundHalfFloor();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
mutableDateTime19.setTime((long) '#');
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.format.DateTimeFormatter dateTimeFormatter27 = null;
java.lang.String str28 = mutableDateTime26.toString(dateTimeFormatter27);
org.joda.time.ReadablePeriod readablePeriod29 = null;
mutableDateTime26.add(readablePeriod29);
org.joda.time.MutableDateTime.Property property31 = mutableDateTime26.hourOfDay();
java.lang.String str32 = mutableDateTime26.toString();
int int33 = mutableDateTime19.compareTo((org.joda.time.ReadableInstant) mutableDateTime26);
java.lang.Object obj34 = mutableDateTime19.clone();
long long35 = mutableDateTime19.getMillis();
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
org.joda.time.ReadablePeriod readablePeriod41 = null;
mutableDateTime38.add(readablePeriod41);
org.joda.time.MutableDateTime.Property property43 = mutableDateTime38.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType44 = property43.getFieldType();
int int45 = mutableDateTime19.get(dateTimeFieldType44);
int int46 = mutableDateTime16.get(dateTimeFieldType44);
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.set(dateTimeFieldType44, 687);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 687 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(date4);
org.junit.Assert.assertEquals(date4.toString(), "Thu Jan 01 00:00:00 UTC 1970");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 1970 + "'", int5 == 1970);
// flaky: org.junit.Assert.assertEquals("'" + str10 + "' != '" + "2020-11-25T01:49:06.611Z" + "'", str10, "2020-11-25T01:49:06.611Z");
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime16);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:06.611Z" + "'", str21, "2020-11-25T01:49:06.611Z");
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:06.611Z" + "'", str28, "2020-11-25T01:49:06.611Z");
org.junit.Assert.assertNotNull(property31);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:06.611Z" + "'", str32, "2020-11-25T01:49:06.611Z");
org.junit.Assert.assertTrue("'" + int33 + "' != '" + (-1) + "'", int33 == (-1));
org.junit.Assert.assertNotNull(obj34);
org.junit.Assert.assertEquals(obj34.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj34), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj34), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long35 + "' != '" + 1606262400035L + "'", long35 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:06.611Z" + "'", str40, "2020-11-25T01:49:06.611Z");
org.junit.Assert.assertNotNull(property43);
org.junit.Assert.assertNotNull(dateTimeFieldType44);
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 0 + "'", int45 == 0);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 0 + "'", int46 == 0);
}
@Test
@Ignore
public void test1677() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1677");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
java.lang.String str9 = mutableDateTime2.toString();
boolean boolean11 = mutableDateTime2.isAfter((long) (short) 1);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.minuteOfHour();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.centuryOfEra();
org.joda.time.ReadableInstant readableInstant22 = null;
mutableDateTime16.setDate(readableInstant22);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfMonth();
int int26 = mutableDateTime24.getCenturyOfEra();
org.joda.time.Chronology chronology28 = null;
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology28);
mutableDateTime29.setSecondOfMinute((int) '4');
int int32 = mutableDateTime29.getMinuteOfDay();
int int33 = mutableDateTime29.getCenturyOfEra();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
int int37 = mutableDateTime36.getDayOfWeek();
java.lang.Object obj38 = null;
org.joda.time.Chronology chronology39 = null;
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime(obj38, chronology39);
org.joda.time.DateTimeZone dateTimeZone41 = mutableDateTime40.getZone();
org.joda.time.MutableDateTime mutableDateTime42 = org.joda.time.MutableDateTime.now(dateTimeZone41);
mutableDateTime36.setZoneRetainFields(dateTimeZone41);
org.joda.time.DateTime dateTime44 = mutableDateTime29.toDateTime(dateTimeZone41);
mutableDateTime24.setZoneRetainFields(dateTimeZone41);
mutableDateTime16.setZone(dateTimeZone41);
org.joda.time.MutableDateTime mutableDateTime47 = org.joda.time.MutableDateTime.now(dateTimeZone41);
org.joda.time.MutableDateTime mutableDateTime48 = new org.joda.time.MutableDateTime(0L, dateTimeZone41);
org.joda.time.MutableDateTime mutableDateTime49 = new org.joda.time.MutableDateTime(dateTimeZone41);
org.joda.time.DateTime dateTime50 = mutableDateTime2.toDateTime(dateTimeZone41);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.658Z" + "'", str4, "2020-11-25T01:49:06.658Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:06.658Z" + "'", str9, "2020-11-25T01:49:06.658Z");
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + true + "'", boolean11 == true);
org.junit.Assert.assertNotNull(property12);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:06.658Z" + "'", str18, "2020-11-25T01:49:06.658Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 0 + "'", int32 == 0);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 19 + "'", int33 == 19);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 3 + "'", int37 == 3);
org.junit.Assert.assertNotNull(dateTimeZone41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime44);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertNotNull(dateTime50);
}
@Test
@Ignore
public void test1678() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1678");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
org.joda.time.Chronology chronology24 = mutableDateTime20.getChronology();
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(chronology24);
org.joda.time.MutableDateTime mutableDateTime26 = mutableDateTime2.toMutableDateTime(chronology24);
boolean boolean28 = mutableDateTime26.isEqual((long) 319);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.716Z" + "'", str4, "2020-11-25T01:49:06.716Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:06.716Z" + "'", str11, "2020-11-25T01:49:06.716Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:06.716Z" + "'", str15, "2020-11-25T01:49:06.716Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:06.716Z" + "'", str22, "2020-11-25T01:49:06.716Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(chronology24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
}
@Test
@Ignore
public void test1679() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1679");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
mutableDateTime2.setDate((long) 6300);
boolean boolean9 = mutableDateTime2.isBefore((long) (byte) 0);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime2.add(readablePeriod10, (int) (short) 0);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime2.millisOfSecond();
java.util.Locale locale14 = null;
java.lang.String str15 = property13.getAsShortText(locale14);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "1" + "'", str15, "1");
}
@Test
@Ignore
public void test1680() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1680");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime8.copy();
boolean boolean10 = mutableDateTime8.isAfterNow();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
}
@Test
@Ignore
public void test1681() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1681");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.dayOfMonth();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime9.dayOfMonth();
java.lang.String str12 = property11.getAsString();
org.joda.time.Interval interval13 = property11.toInterval();
int int14 = property11.get();
boolean boolean15 = property7.equals((java.lang.Object) property11);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:06.811Z" + "'", str4, "2020-11-25T01:49:06.811Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "25" + "'", str12, "25");
org.junit.Assert.assertNotNull(interval13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 25 + "'", int14 == 25);
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
}
@Test
@Ignore
public void test1682() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1682");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
mutableDateTime5.addHours(59);
java.lang.Object obj9 = mutableDateTime5.clone();
// The following exception was thrown during execution in test generation
try {
mutableDateTime5.setDayOfWeek(48);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 48 for dayOfWeek must be in the range [1,7]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(obj9);
org.junit.Assert.assertEquals(obj9.toString(), "2020-12-03T11:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj9), "2020-12-03T11:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj9), "2020-12-03T11:00:00.000Z");
}
@Test
public void test1683() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1683");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
java.lang.String str8 = property7.toString();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundCeiling();
int int10 = property7.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime11 = property7.getMutableDateTime();
long long12 = property7.remainder();
int int13 = property7.getMaximumValue();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertEquals("'" + str8 + "' != '" + "Property[yearOfCentury]" + "'", str8, "Property[yearOfCentury]");
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 99 + "'", int10 == 99);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertTrue("'" + long12 + "' != '" + 0L + "'", long12 == 0L);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 99 + "'", int13 == 99);
}
@Test
@Ignore
public void test1684() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1684");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
int int6 = mutableDateTime2.getMonthOfYear();
int int7 = mutableDateTime2.getHourOfDay();
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setDayOfMonth(6291);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6291 for dayOfMonth must be in the range [1,30]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 11 + "'", int6 == 11);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
}
@Test
@Ignore
public void test1685() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1685");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.Interval interval4 = property2.toInterval();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.format.DateTimeFormatter dateTimeFormatter8 = null;
java.lang.String str9 = mutableDateTime7.toString(dateTimeFormatter8);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime7.add(readablePeriod10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime7.centuryOfEra();
boolean boolean13 = property2.equals((java.lang.Object) mutableDateTime7);
mutableDateTime7.setTime((long) ' ');
org.joda.time.MutableDateTime.Property property16 = mutableDateTime7.dayOfWeek();
int int17 = property16.getMaximumValue();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(interval4);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:06.963Z" + "'", str9, "2020-11-25T01:49:06.963Z");
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 7 + "'", int17 == 7);
}
@Test
@Ignore
public void test1686() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1686");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
int int6 = mutableDateTime3.getMinuteOfDay();
int int7 = mutableDateTime3.getCenturyOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
org.joda.time.MutableDateTime mutableDateTime16 = org.joda.time.MutableDateTime.now(dateTimeZone15);
mutableDateTime10.setZoneRetainFields(dateTimeZone15);
org.joda.time.DateTime dateTime18 = mutableDateTime3.toDateTime(dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(259200010L, dateTimeZone15);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime19.dayOfYear();
int int21 = mutableDateTime19.getDayOfWeek();
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.dayOfMonth();
int int24 = mutableDateTime22.getCenturyOfEra();
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology26);
mutableDateTime27.setSecondOfMinute((int) '4');
int int30 = mutableDateTime27.getMinuteOfDay();
int int31 = mutableDateTime27.getCenturyOfEra();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
int int35 = mutableDateTime34.getDayOfWeek();
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.DateTimeZone dateTimeZone39 = mutableDateTime38.getZone();
org.joda.time.MutableDateTime mutableDateTime40 = org.joda.time.MutableDateTime.now(dateTimeZone39);
mutableDateTime34.setZoneRetainFields(dateTimeZone39);
org.joda.time.DateTime dateTime42 = mutableDateTime27.toDateTime(dateTimeZone39);
mutableDateTime22.setZoneRetainFields(dateTimeZone39);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(dateTimeZone39);
org.joda.time.DateTime dateTime45 = mutableDateTime19.toDateTime(dateTimeZone39);
org.joda.time.MutableDateTime mutableDateTime46 = org.joda.time.MutableDateTime.now(dateTimeZone39);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 0 + "'", int6 == 0);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 19 + "'", int7 == 19);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 7 + "'", int21 == 7);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 20 + "'", int24 == 20);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 0 + "'", int30 == 0);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 19 + "'", int31 == 19);
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 3 + "'", int35 == 3);
org.junit.Assert.assertNotNull(dateTimeZone39);
org.junit.Assert.assertNotNull(mutableDateTime40);
org.junit.Assert.assertNotNull(dateTime42);
org.junit.Assert.assertNotNull(dateTime45);
org.junit.Assert.assertNotNull(mutableDateTime46);
}
@Test
public void test1687() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1687");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
mutableDateTime2.add((long) 3);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.monthOfYear();
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime2.toString(dateTimeFormatter13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
java.util.Locale locale17 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime18 = property15.set("2020-11-25T01:44:49.966Z", locale17);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value \"2020-11-25T01:44:49.966Z\" for secondOfDay is not supported");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.062Z" + "'", str4, "2020-11-25T01:49:07.062Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property12);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:07.065Z" + "'", str14, "2020-11-25T01:49:07.065Z");
org.junit.Assert.assertNotNull(property15);
}
@Test
@Ignore
public void test1688() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1688");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
int int3 = mutableDateTime0.getEra();
java.lang.Object obj4 = null;
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime(obj4, chronology5);
org.joda.time.format.DateTimeFormatter dateTimeFormatter7 = null;
java.lang.String str8 = mutableDateTime6.toString(dateTimeFormatter7);
org.joda.time.ReadablePeriod readablePeriod9 = null;
mutableDateTime6.add(readablePeriod9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime6.hourOfDay();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime6.dayOfWeek();
int int13 = property12.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime15 = property12.addWrapField(0);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.DateTimeZone dateTimeZone19 = mutableDateTime18.getZone();
mutableDateTime18.setMinuteOfDay(4);
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.format.DateTimeFormatter dateTimeFormatter25 = null;
java.lang.String str26 = mutableDateTime24.toString(dateTimeFormatter25);
int int27 = mutableDateTime24.getYearOfCentury();
org.joda.time.Chronology chronology28 = mutableDateTime24.getChronology();
int int29 = mutableDateTime24.getWeekOfWeekyear();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.DateTimeZone dateTimeZone33 = mutableDateTime32.getZone();
org.joda.time.DateTime dateTime34 = mutableDateTime24.toDateTime(dateTimeZone33);
org.joda.time.MutableDateTime mutableDateTime35 = mutableDateTime18.toMutableDateTime(dateTimeZone33);
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(dateTimeZone33);
org.joda.time.DateTime dateTime37 = mutableDateTime15.toDateTime(dateTimeZone33);
org.joda.time.DateTime dateTime38 = dateTime37.toDateTime();
java.lang.Object obj40 = null;
org.joda.time.Chronology chronology41 = null;
org.joda.time.MutableDateTime mutableDateTime42 = new org.joda.time.MutableDateTime(obj40, chronology41);
org.joda.time.format.DateTimeFormatter dateTimeFormatter43 = null;
java.lang.String str44 = mutableDateTime42.toString(dateTimeFormatter43);
org.joda.time.ReadablePeriod readablePeriod45 = null;
mutableDateTime42.add(readablePeriod45);
org.joda.time.MutableDateTime.Property property47 = mutableDateTime42.hourOfDay();
org.joda.time.MutableDateTime.Property property48 = mutableDateTime42.dayOfWeek();
int int49 = property48.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime51 = property48.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime52 = property48.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod53 = null;
mutableDateTime52.add(readablePeriod53, 40);
java.lang.Object obj56 = null;
org.joda.time.Chronology chronology57 = null;
org.joda.time.MutableDateTime mutableDateTime58 = new org.joda.time.MutableDateTime(obj56, chronology57);
org.joda.time.format.DateTimeFormatter dateTimeFormatter59 = null;
java.lang.String str60 = mutableDateTime58.toString(dateTimeFormatter59);
int int61 = mutableDateTime58.getYearOfCentury();
org.joda.time.Chronology chronology62 = mutableDateTime58.getChronology();
org.joda.time.MutableDateTime mutableDateTime63 = mutableDateTime52.toMutableDateTime(chronology62);
org.joda.time.MutableDateTime mutableDateTime64 = new org.joda.time.MutableDateTime((long) 100, chronology62);
org.joda.time.MutableDateTime mutableDateTime65 = dateTime38.toMutableDateTime(chronology62);
org.joda.time.DateTime dateTime66 = mutableDateTime0.toDateTime(chronology62);
int int67 = dateTime66.getDayOfYear();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 1 + "'", int3 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T01:49:07.090Z" + "'", str8, "2020-11-25T01:49:07.090Z");
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 7 + "'", int13 == 7);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertNotNull(dateTimeZone19);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:07.090Z" + "'", str26, "2020-11-25T01:49:07.090Z");
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 20 + "'", int27 == 20);
org.junit.Assert.assertNotNull(chronology28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 48 + "'", int29 == 48);
org.junit.Assert.assertNotNull(dateTimeZone33);
org.junit.Assert.assertNotNull(dateTime34);
org.junit.Assert.assertNotNull(mutableDateTime35);
org.junit.Assert.assertNotNull(dateTime37);
org.junit.Assert.assertNotNull(dateTime38);
// flaky: org.junit.Assert.assertEquals("'" + str44 + "' != '" + "2020-11-25T01:49:07.090Z" + "'", str44, "2020-11-25T01:49:07.090Z");
org.junit.Assert.assertNotNull(property47);
org.junit.Assert.assertNotNull(property48);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 7 + "'", int49 == 7);
org.junit.Assert.assertNotNull(mutableDateTime51);
org.junit.Assert.assertNotNull(mutableDateTime52);
// flaky: org.junit.Assert.assertEquals("'" + str60 + "' != '" + "2020-11-25T01:49:07.090Z" + "'", str60, "2020-11-25T01:49:07.090Z");
org.junit.Assert.assertTrue("'" + int61 + "' != '" + 20 + "'", int61 == 20);
org.junit.Assert.assertNotNull(chronology62);
org.junit.Assert.assertNotNull(mutableDateTime63);
org.junit.Assert.assertNotNull(mutableDateTime65);
org.junit.Assert.assertNotNull(dateTime66);
org.junit.Assert.assertTrue("'" + int67 + "' != '" + 330 + "'", int67 == 330);
}
@Test
@Ignore
public void test1689() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1689");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property15.add(2189);
java.lang.String str18 = mutableDateTime17.toString();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.yearOfCentury();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
org.joda.time.MutableDateTime.Property property28 = mutableDateTime21.millisOfDay();
mutableDateTime21.add((long) 3);
boolean boolean31 = mutableDateTime17.isEqual((org.joda.time.ReadableInstant) mutableDateTime21);
int int32 = mutableDateTime17.getWeekOfWeekyear();
int int33 = mutableDateTime17.getYearOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.146Z" + "'", str4, "2020-11-25T01:49:07.146Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T02:25:36.146Z" + "'", str18, "2020-11-25T02:25:36.146Z");
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:07.146Z" + "'", str23, "2020-11-25T01:49:07.146Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 48 + "'", int32 == 48);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 2020 + "'", int33 == 2020);
}
@Test
@Ignore
public void test1690() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1690");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime23.toMutableDateTime();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.format.DateTimeFormatter dateTimeFormatter28 = null;
java.lang.String str29 = mutableDateTime27.toString(dateTimeFormatter28);
org.joda.time.ReadablePeriod readablePeriod30 = null;
mutableDateTime27.add(readablePeriod30);
org.joda.time.MutableDateTime.Property property32 = mutableDateTime27.hourOfDay();
org.joda.time.MutableDateTime.Property property33 = mutableDateTime27.dayOfWeek();
int int34 = property33.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime36 = property33.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime37 = property33.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod38 = null;
mutableDateTime37.add(readablePeriod38, 40);
java.lang.Object obj41 = null;
org.joda.time.Chronology chronology42 = null;
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime(obj41, chronology42);
org.joda.time.format.DateTimeFormatter dateTimeFormatter44 = null;
java.lang.String str45 = mutableDateTime43.toString(dateTimeFormatter44);
int int46 = mutableDateTime43.getYearOfCentury();
org.joda.time.Chronology chronology47 = mutableDateTime43.getChronology();
org.joda.time.MutableDateTime mutableDateTime48 = mutableDateTime37.toMutableDateTime(chronology47);
org.joda.time.MutableDateTime mutableDateTime49 = org.joda.time.MutableDateTime.now(chronology47);
org.joda.time.MutableDateTime.Property property50 = mutableDateTime49.dayOfYear();
int int51 = mutableDateTime49.getYearOfCentury();
mutableDateTime49.addSeconds(319);
mutableDateTime24.setDate((org.joda.time.ReadableInstant) mutableDateTime49);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.206Z" + "'", str4, "2020-11-25T01:49:07.206Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:07.206Z" + "'", str20, "2020-11-25T01:49:07.206Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
// flaky: org.junit.Assert.assertEquals("'" + str29 + "' != '" + "2020-11-25T01:49:07.206Z" + "'", str29, "2020-11-25T01:49:07.206Z");
org.junit.Assert.assertNotNull(property32);
org.junit.Assert.assertNotNull(property33);
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 7 + "'", int34 == 7);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertNotNull(mutableDateTime37);
// flaky: org.junit.Assert.assertEquals("'" + str45 + "' != '" + "2020-11-25T01:49:07.206Z" + "'", str45, "2020-11-25T01:49:07.206Z");
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 20 + "'", int46 == 20);
org.junit.Assert.assertNotNull(chronology47);
org.junit.Assert.assertNotNull(mutableDateTime48);
org.junit.Assert.assertNotNull(mutableDateTime49);
org.junit.Assert.assertNotNull(property50);
org.junit.Assert.assertTrue("'" + int51 + "' != '" + 20 + "'", int51 == 20);
}
@Test
@Ignore
public void test1691() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1691");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) 100, chronology29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology29);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology36);
mutableDateTime37.setSecondOfMinute((int) '4');
int int40 = mutableDateTime37.getMinuteOfDay();
mutableDateTime37.setDate((long) 6300);
boolean boolean44 = mutableDateTime37.isBefore((long) (byte) 0);
boolean boolean45 = mutableDateTime34.isEqual((org.joda.time.ReadableInstant) mutableDateTime37);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:07.254Z" + "'", str11, "2020-11-25T01:49:07.254Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:07.254Z" + "'", str27, "2020-11-25T01:49:07.254Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 0 + "'", int40 == 0);
org.junit.Assert.assertTrue("'" + boolean44 + "' != '" + false + "'", boolean44 == false);
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + false + "'", boolean45 == false);
}
@Test
@Ignore
public void test1692() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1692");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
long long9 = mutableDateTime8.getMillis();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.centuryOfEra();
org.joda.time.ReadableInstant readableInstant18 = null;
mutableDateTime12.setDate(readableInstant18);
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime20.dayOfMonth();
int int22 = mutableDateTime20.getCenturyOfEra();
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology24);
mutableDateTime25.setSecondOfMinute((int) '4');
int int28 = mutableDateTime25.getMinuteOfDay();
int int29 = mutableDateTime25.getCenturyOfEra();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
int int33 = mutableDateTime32.getDayOfWeek();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
org.joda.time.DateTimeZone dateTimeZone37 = mutableDateTime36.getZone();
org.joda.time.MutableDateTime mutableDateTime38 = org.joda.time.MutableDateTime.now(dateTimeZone37);
mutableDateTime32.setZoneRetainFields(dateTimeZone37);
org.joda.time.DateTime dateTime40 = mutableDateTime25.toDateTime(dateTimeZone37);
mutableDateTime20.setZoneRetainFields(dateTimeZone37);
mutableDateTime12.setZone(dateTimeZone37);
org.joda.time.DateTime dateTime43 = mutableDateTime8.toDateTime(dateTimeZone37);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(dateTimeZone37);
java.lang.Object obj45 = null;
org.joda.time.Chronology chronology46 = null;
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime(obj45, chronology46);
org.joda.time.format.DateTimeFormatter dateTimeFormatter48 = null;
java.lang.String str49 = mutableDateTime47.toString(dateTimeFormatter48);
int int50 = mutableDateTime47.getYearOfCentury();
org.joda.time.Chronology chronology51 = mutableDateTime47.getChronology();
int int52 = mutableDateTime47.getWeekOfWeekyear();
mutableDateTime47.setMinuteOfHour(0);
java.lang.Object obj55 = null;
org.joda.time.Chronology chronology56 = null;
org.joda.time.MutableDateTime mutableDateTime57 = new org.joda.time.MutableDateTime(obj55, chronology56);
org.joda.time.format.DateTimeFormatter dateTimeFormatter58 = null;
java.lang.String str59 = mutableDateTime57.toString(dateTimeFormatter58);
int int60 = mutableDateTime57.getYearOfCentury();
org.joda.time.Chronology chronology61 = mutableDateTime57.getChronology();
int int62 = mutableDateTime57.getWeekOfWeekyear();
boolean boolean63 = mutableDateTime47.isBefore((org.joda.time.ReadableInstant) mutableDateTime57);
org.joda.time.ReadablePeriod readablePeriod64 = null;
mutableDateTime57.add(readablePeriod64);
boolean boolean66 = mutableDateTime44.isBefore((org.joda.time.ReadableInstant) mutableDateTime57);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertTrue("'" + long9 + "' != '" + 1580521747389L + "'", long9 == 1580521747389L);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:07.389Z" + "'", str14, "2020-11-25T01:49:07.389Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 0 + "'", int28 == 0);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 19 + "'", int29 == 19);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 3 + "'", int33 == 3);
org.junit.Assert.assertNotNull(dateTimeZone37);
org.junit.Assert.assertNotNull(mutableDateTime38);
org.junit.Assert.assertNotNull(dateTime40);
org.junit.Assert.assertNotNull(dateTime43);
// flaky: org.junit.Assert.assertEquals("'" + str49 + "' != '" + "2020-11-25T01:49:07.389Z" + "'", str49, "2020-11-25T01:49:07.389Z");
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 20 + "'", int50 == 20);
org.junit.Assert.assertNotNull(chronology51);
org.junit.Assert.assertTrue("'" + int52 + "' != '" + 48 + "'", int52 == 48);
// flaky: org.junit.Assert.assertEquals("'" + str59 + "' != '" + "2020-11-25T01:49:07.389Z" + "'", str59, "2020-11-25T01:49:07.389Z");
org.junit.Assert.assertTrue("'" + int60 + "' != '" + 20 + "'", int60 == 20);
org.junit.Assert.assertNotNull(chronology61);
org.junit.Assert.assertTrue("'" + int62 + "' != '" + 48 + "'", int62 == 48);
org.junit.Assert.assertTrue("'" + boolean63 + "' != '" + true + "'", boolean63 == true);
// flaky: org.junit.Assert.assertTrue("'" + boolean66 + "' != '" + false + "'", boolean66 == false);
}
@Test
@Ignore
public void test1693() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1693");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
mutableDateTime2.setMillisOfDay(0);
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
mutableDateTime23.setTime((long) '#');
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
java.lang.String str36 = mutableDateTime30.toString();
int int37 = mutableDateTime23.compareTo((org.joda.time.ReadableInstant) mutableDateTime30);
org.joda.time.MutableDateTime mutableDateTime38 = mutableDateTime23.copy();
java.lang.Object obj39 = null;
org.joda.time.Chronology chronology40 = null;
org.joda.time.MutableDateTime mutableDateTime41 = new org.joda.time.MutableDateTime(obj39, chronology40);
org.joda.time.format.DateTimeFormatter dateTimeFormatter42 = null;
java.lang.String str43 = mutableDateTime41.toString(dateTimeFormatter42);
int int44 = mutableDateTime41.getYearOfCentury();
org.joda.time.Chronology chronology45 = mutableDateTime41.getChronology();
org.joda.time.MutableDateTime mutableDateTime46 = org.joda.time.MutableDateTime.now(chronology45);
org.joda.time.MutableDateTime mutableDateTime47 = mutableDateTime23.toMutableDateTime(chronology45);
org.joda.time.MutableDateTime mutableDateTime48 = mutableDateTime2.toMutableDateTime(chronology45);
boolean boolean50 = mutableDateTime48.isBefore((long) 185);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.460Z" + "'", str4, "2020-11-25T01:49:07.460Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:07.460Z" + "'", str11, "2020-11-25T01:49:07.460Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:07.460Z" + "'", str15, "2020-11-25T01:49:07.460Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:07.460Z" + "'", str25, "2020-11-25T01:49:07.460Z");
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:07.460Z" + "'", str32, "2020-11-25T01:49:07.460Z");
org.junit.Assert.assertNotNull(property35);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:07.460Z" + "'", str36, "2020-11-25T01:49:07.460Z");
org.junit.Assert.assertTrue("'" + int37 + "' != '" + (-1) + "'", int37 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime38);
// flaky: org.junit.Assert.assertEquals("'" + str43 + "' != '" + "2020-11-25T01:49:07.460Z" + "'", str43, "2020-11-25T01:49:07.460Z");
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 20 + "'", int44 == 20);
org.junit.Assert.assertNotNull(chronology45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertNotNull(mutableDateTime48);
org.junit.Assert.assertTrue("'" + boolean50 + "' != '" + false + "'", boolean50 == false);
}
@Test
public void test1694() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1694");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.centuryOfEra();
int int9 = mutableDateTime2.getSecondOfMinute();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.518Z" + "'", str4, "2020-11-25T01:49:07.518Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
// flaky: org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
}
@Test
public void test1695() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1695");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
int int4 = mutableDateTime2.getSecondOfDay();
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 6547 + "'", int4 == 6547);
}
@Test
@Ignore
public void test1696() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1696");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
int int4 = property3.get();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.format.DateTimeFormatter dateTimeFormatter8 = null;
java.lang.String str9 = mutableDateTime7.toString(dateTimeFormatter8);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime7.add(readablePeriod10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime7.centuryOfEra();
org.joda.time.ReadableInstant readableInstant13 = null;
mutableDateTime7.setDate(readableInstant13);
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime15.dayOfMonth();
int int17 = mutableDateTime15.getCenturyOfEra();
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology19);
mutableDateTime20.setSecondOfMinute((int) '4');
int int23 = mutableDateTime20.getMinuteOfDay();
int int24 = mutableDateTime20.getCenturyOfEra();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
int int28 = mutableDateTime27.getDayOfWeek();
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.DateTimeZone dateTimeZone32 = mutableDateTime31.getZone();
org.joda.time.MutableDateTime mutableDateTime33 = org.joda.time.MutableDateTime.now(dateTimeZone32);
mutableDateTime27.setZoneRetainFields(dateTimeZone32);
org.joda.time.DateTime dateTime35 = mutableDateTime20.toDateTime(dateTimeZone32);
mutableDateTime15.setZoneRetainFields(dateTimeZone32);
mutableDateTime7.setZone(dateTimeZone32);
org.joda.time.MutableDateTime mutableDateTime38 = org.joda.time.MutableDateTime.now(dateTimeZone32);
long long39 = property3.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime38);
org.joda.time.MutableDateTime mutableDateTime40 = property3.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime41 = property3.getMutableDateTime();
org.joda.time.Interval interval42 = property3.toInterval();
org.joda.time.DurationField durationField43 = property3.getLeapDurationField();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:07.569Z" + "'", str9, "2020-11-25T01:49:07.569Z");
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 20 + "'", int17 == 20);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 0 + "'", int23 == 0);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 19 + "'", int24 == 19);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 3 + "'", int28 == 3);
org.junit.Assert.assertNotNull(dateTimeZone32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(dateTime35);
org.junit.Assert.assertNotNull(mutableDateTime38);
org.junit.Assert.assertTrue("'" + long39 + "' != '" + (-18591L) + "'", long39 == (-18591L));
org.junit.Assert.assertNotNull(mutableDateTime40);
org.junit.Assert.assertNotNull(mutableDateTime41);
org.junit.Assert.assertNotNull(interval42);
org.junit.Assert.assertNull(durationField43);
}
@Test
@Ignore
public void test1697() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1697");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime13.weekOfWeekyear();
org.joda.time.DateTimeFieldType dateTimeFieldType16 = property15.getFieldType();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.628Z" + "'", str4, "2020-11-25T01:49:07.628Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(dateTimeFieldType16);
}
@Test
public void test1698() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1698");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
mutableDateTime9.addDays(19);
mutableDateTime9.setMillisOfDay(49);
mutableDateTime9.addWeekyears(693);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime9.secondOfDay();
org.joda.time.MutableDateTime.Property property24 = mutableDateTime9.year();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.662Z" + "'", str4, "2020-11-25T01:49:07.662Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:07.662Z" + "'", str11, "2020-11-25T01:49:07.662Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:07.662Z" + "'", str15, "2020-11-25T01:49:07.662Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertNotNull(property24);
}
@Test
@Ignore
public void test1699() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1699");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property15.addWrapField((int) '4');
java.lang.String str18 = mutableDateTime17.toString();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.hourOfDay();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
int int28 = property27.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime30 = property27.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime31 = property27.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime32 = property27.roundHalfFloor();
org.joda.time.Chronology chronology34 = null;
org.joda.time.MutableDateTime mutableDateTime35 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology34);
mutableDateTime35.setSecondOfMinute((int) '4');
int int38 = mutableDateTime35.getMinuteOfDay();
java.lang.Object obj40 = null;
org.joda.time.Chronology chronology41 = null;
org.joda.time.MutableDateTime mutableDateTime42 = new org.joda.time.MutableDateTime(obj40, chronology41);
org.joda.time.format.DateTimeFormatter dateTimeFormatter43 = null;
java.lang.String str44 = mutableDateTime42.toString(dateTimeFormatter43);
org.joda.time.ReadablePeriod readablePeriod45 = null;
mutableDateTime42.add(readablePeriod45);
org.joda.time.MutableDateTime.Property property47 = mutableDateTime42.centuryOfEra();
org.joda.time.DateTimeField dateTimeField48 = property47.getField();
java.lang.Object obj49 = null;
org.joda.time.Chronology chronology50 = null;
org.joda.time.MutableDateTime mutableDateTime51 = new org.joda.time.MutableDateTime(obj49, chronology50);
org.joda.time.format.DateTimeFormatter dateTimeFormatter52 = null;
java.lang.String str53 = mutableDateTime51.toString(dateTimeFormatter52);
org.joda.time.ReadablePeriod readablePeriod54 = null;
mutableDateTime51.add(readablePeriod54);
org.joda.time.MutableDateTime.Property property56 = mutableDateTime51.centuryOfEra();
int int57 = property47.getDifference((org.joda.time.ReadableInstant) mutableDateTime51);
org.joda.time.MutableDateTime mutableDateTime58 = mutableDateTime51.toMutableDateTimeISO();
java.lang.Object obj59 = null;
org.joda.time.Chronology chronology60 = null;
org.joda.time.MutableDateTime mutableDateTime61 = new org.joda.time.MutableDateTime(obj59, chronology60);
org.joda.time.DateTimeZone dateTimeZone62 = mutableDateTime61.getZone();
org.joda.time.MutableDateTime mutableDateTime63 = mutableDateTime58.toMutableDateTime(dateTimeZone62);
org.joda.time.MutableDateTime mutableDateTime64 = new org.joda.time.MutableDateTime((long) 815, dateTimeZone62);
mutableDateTime35.setZoneRetainFields(dateTimeZone62);
org.joda.time.MutableDateTime mutableDateTime66 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime32, dateTimeZone62);
org.joda.time.MutableDateTime mutableDateTime67 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime17, dateTimeZone62);
org.joda.time.MutableDateTime.Property property68 = mutableDateTime67.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime70 = property68.set(422);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.685Z" + "'", str4, "2020-11-25T01:49:07.685Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:59.685Z" + "'", str18, "2020-11-25T01:49:59.685Z");
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:07.685Z" + "'", str23, "2020-11-25T01:49:07.685Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 7 + "'", int28 == 7);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime32);
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 0 + "'", int38 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str44 + "' != '" + "2020-11-25T01:49:07.685Z" + "'", str44, "2020-11-25T01:49:07.685Z");
org.junit.Assert.assertNotNull(property47);
org.junit.Assert.assertNotNull(dateTimeField48);
// flaky: org.junit.Assert.assertEquals("'" + str53 + "' != '" + "2020-11-25T01:49:07.685Z" + "'", str53, "2020-11-25T01:49:07.685Z");
org.junit.Assert.assertNotNull(property56);
org.junit.Assert.assertTrue("'" + int57 + "' != '" + 0 + "'", int57 == 0);
org.junit.Assert.assertNotNull(mutableDateTime58);
org.junit.Assert.assertNotNull(dateTimeZone62);
org.junit.Assert.assertNotNull(mutableDateTime63);
org.junit.Assert.assertNotNull(property68);
org.junit.Assert.assertNotNull(mutableDateTime70);
}
@Test
@Ignore
public void test1700() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1700");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
int int10 = mutableDateTime2.getWeekOfWeekyear();
mutableDateTime2.add(0L);
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setDate(2400000, 6472, 493);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6472 for monthOfYear must be in the range [1,12]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.781Z" + "'", str4, "2020-11-25T01:49:07.781Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 48 + "'", int10 == 48);
}
@Test
@Ignore
public void test1701() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1701");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime13.dayOfWeek();
org.joda.time.Chronology chronology15 = null;
mutableDateTime13.setChronology(chronology15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.monthOfYear();
int int18 = property17.getLeapAmount();
java.lang.String str19 = property17.getAsString();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.817Z" + "'", str4, "2020-11-25T01:49:07.817Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "11" + "'", str19, "11");
}
@Test
public void test1702() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1702");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime10 = property7.getMutableDateTime();
java.lang.String str11 = property7.getName();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:07.850Z" + "'", str4, "2020-11-25T01:49:07.850Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "centuryOfEra" + "'", str11, "centuryOfEra");
}
@Test
public void test1703() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1703");
org.joda.time.MutableDateTime mutableDateTime1 = org.joda.time.MutableDateTime.parse("2020-11-25T01:44:51.967Z");
int int2 = mutableDateTime1.getSecondOfDay();
boolean boolean4 = mutableDateTime1.isAfter(6349031L);
org.junit.Assert.assertNotNull(mutableDateTime1);
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 6291 + "'", int2 == 6291);
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
}
@Test
@Ignore
public void test1704() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1704");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
org.joda.time.MutableDateTime.Property property4 = mutableDateTime3.dayOfYear();
java.util.GregorianCalendar gregorianCalendar5 = mutableDateTime3.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime3.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime7.dayOfMonth();
int int9 = mutableDateTime7.getCenturyOfEra();
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology11);
mutableDateTime12.setSecondOfMinute((int) '4');
int int15 = mutableDateTime12.getMinuteOfDay();
int int16 = mutableDateTime12.getCenturyOfEra();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
int int20 = mutableDateTime19.getDayOfWeek();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.DateTimeZone dateTimeZone24 = mutableDateTime23.getZone();
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(dateTimeZone24);
mutableDateTime19.setZoneRetainFields(dateTimeZone24);
org.joda.time.DateTime dateTime27 = mutableDateTime12.toDateTime(dateTimeZone24);
mutableDateTime7.setZoneRetainFields(dateTimeZone24);
org.joda.time.MutableDateTime mutableDateTime29 = org.joda.time.MutableDateTime.now(dateTimeZone24);
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime3.toMutableDateTime(dateTimeZone24);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) '#', dateTimeZone24);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(dateTimeZone24);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(gregorianCalendar5);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 20 + "'", int9 == 20);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 19 + "'", int16 == 19);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 3 + "'", int20 == 3);
org.junit.Assert.assertNotNull(dateTimeZone24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(dateTime27);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime30);
}
@Test
public void test1705() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1705");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime2.centuryOfEra();
boolean boolean11 = mutableDateTime2.isBeforeNow();
mutableDateTime2.setMinuteOfDay((int) (byte) 1);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:08.029Z" + "'", str4, "2020-11-25T01:49:08.029Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
}
@Test
@Ignore
public void test1706() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1706");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime13.weekOfWeekyear();
java.util.Locale locale16 = null;
int int17 = property15.getMaximumShortTextLength(locale16);
org.joda.time.DurationField durationField18 = property15.getDurationField();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:08.058Z" + "'", str4, "2020-11-25T01:49:08.058Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 2 + "'", int17 == 2);
org.junit.Assert.assertNotNull(durationField18);
}
@Test
@Ignore
public void test1707() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1707");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
mutableDateTime13.addDays(2189);
int int17 = mutableDateTime13.getSecondOfMinute();
int int18 = mutableDateTime13.getMinuteOfHour();
mutableDateTime13.add((long) 916);
org.joda.time.DateTimeZone dateTimeZone21 = mutableDateTime13.getZone();
int int22 = mutableDateTime13.getMillisOfDay();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:08.116Z" + "'", str4, "2020-11-25T01:49:08.116Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
// flaky: org.junit.Assert.assertTrue("'" + int17 + "' != '" + 8 + "'", int17 == 8);
// flaky: org.junit.Assert.assertTrue("'" + int18 + "' != '" + 49 + "'", int18 == 49);
org.junit.Assert.assertNotNull(dateTimeZone21);
// flaky: org.junit.Assert.assertTrue("'" + int22 + "' != '" + 6549032 + "'", int22 == 6549032);
}
@Test
@Ignore
public void test1708() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1708");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology5);
mutableDateTime6.setSecondOfMinute((int) '4');
int int9 = mutableDateTime6.getMinuteOfDay();
int int10 = mutableDateTime6.getCenturyOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
int int14 = mutableDateTime13.getDayOfWeek();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.MutableDateTime mutableDateTime19 = org.joda.time.MutableDateTime.now(dateTimeZone18);
mutableDateTime13.setZoneRetainFields(dateTimeZone18);
org.joda.time.DateTime dateTime21 = mutableDateTime6.toDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime22 = org.joda.time.MutableDateTime.now(dateTimeZone18);
long long23 = property2.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime22);
org.joda.time.MutableDateTime mutableDateTime24 = property2.getMutableDateTime();
java.util.Locale locale25 = null;
int int26 = property2.getMaximumShortTextLength(locale25);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 19 + "'", int10 == 19);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 3 + "'", int14 == 3);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertTrue("'" + long23 + "' != '" + (-50L) + "'", long23 == (-50L));
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 9 + "'", int26 == 9);
}
@Test
@Ignore
public void test1709() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1709");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
mutableDateTime2.setDate((long) 6300);
boolean boolean9 = mutableDateTime2.isBefore((long) (byte) 0);
boolean boolean11 = mutableDateTime2.equals((java.lang.Object) "2020-11-25T01:44:57.138Z");
java.lang.Object obj13 = null;
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime(obj13, chronology14);
org.joda.time.format.DateTimeFormatter dateTimeFormatter16 = null;
java.lang.String str17 = mutableDateTime15.toString(dateTimeFormatter16);
org.joda.time.ReadablePeriod readablePeriod18 = null;
mutableDateTime15.add(readablePeriod18);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime15.hourOfDay();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime15.dayOfWeek();
int int22 = property21.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime24 = property21.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime25 = property21.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod26 = null;
mutableDateTime25.add(readablePeriod26, 40);
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.format.DateTimeFormatter dateTimeFormatter32 = null;
java.lang.String str33 = mutableDateTime31.toString(dateTimeFormatter32);
int int34 = mutableDateTime31.getYearOfCentury();
org.joda.time.Chronology chronology35 = mutableDateTime31.getChronology();
org.joda.time.MutableDateTime mutableDateTime36 = mutableDateTime25.toMutableDateTime(chronology35);
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime((long) 100, chronology35);
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(chronology35);
mutableDateTime2.setChronology(chronology35);
int int40 = mutableDateTime2.getRoundingMode();
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// flaky: org.junit.Assert.assertEquals("'" + str17 + "' != '" + "2020-11-25T01:49:08.264Z" + "'", str17, "2020-11-25T01:49:08.264Z");
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 7 + "'", int22 == 7);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime25);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:49:08.264Z" + "'", str33, "2020-11-25T01:49:08.264Z");
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 20 + "'", int34 == 20);
org.junit.Assert.assertNotNull(chronology35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 0 + "'", int40 == 0);
}
@Test
@Ignore
public void test1710() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1710");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime13.add(readablePeriod14, 40);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime13.toMutableDateTime(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 100, chronology23);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime25.dayOfYear();
int int27 = property26.getMaximumValueOverall();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:08.302Z" + "'", str5, "2020-11-25T01:49:08.302Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:08.302Z" + "'", str21, "2020-11-25T01:49:08.302Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 366 + "'", int27 == 366);
}
@Test
public void test1711() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1711");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
int int4 = mutableDateTime2.getSecondOfMinute();
mutableDateTime2.add(6459345L);
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 8 + "'", int4 == 8);
}
@Test
public void test1712() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1712");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
int int3 = mutableDateTime1.getMinuteOfHour();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime1.centuryOfEra();
mutableDateTime1.setMillisOfDay(0);
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.yearOfCentury();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime9.millisOfDay();
mutableDateTime9.add((long) 3);
mutableDateTime9.addWeekyears((int) (byte) 100);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime9.weekOfWeekyear();
boolean boolean23 = mutableDateTime9.isBefore((long) (byte) 1);
mutableDateTime1.setMillis((org.joda.time.ReadableInstant) mutableDateTime9);
mutableDateTime9.addMinutes(855);
java.lang.String str27 = mutableDateTime9.toString();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertNotNull(property4);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:08.391Z" + "'", str11, "2020-11-25T01:49:08.391Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2120-11-27T16:04:08.394Z" + "'", str27, "2120-11-27T16:04:08.394Z");
}
@Test
public void test1713() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1713");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
java.util.Locale locale2 = null;
int int3 = property1.getMaximumTextLength(locale2);
org.joda.time.MutableDateTime mutableDateTime5 = property1.add(693);
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime5, chronology6);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 2 + "'", int3 == 2);
org.junit.Assert.assertNotNull(mutableDateTime5);
}
@Test
@Ignore
public void test1714() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1714");
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime17 = property15.roundHalfCeiling();
org.joda.time.DateTimeField dateTimeField18 = property15.getField();
int int19 = property15.getMinimumValueOverall();
org.joda.time.MutableDateTime mutableDateTime20 = property15.roundFloor();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime20.secondOfDay();
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
int int30 = mutableDateTime25.getWeekOfWeekyear();
java.lang.Object obj31 = null;
org.joda.time.Chronology chronology32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(obj31, chronology32);
org.joda.time.DateTimeZone dateTimeZone34 = mutableDateTime33.getZone();
org.joda.time.DateTime dateTime35 = mutableDateTime25.toDateTime(dateTimeZone34);
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime((-1L), dateTimeZone34);
mutableDateTime20.setZone(dateTimeZone34);
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property40 = mutableDateTime39.dayOfMonth();
boolean boolean42 = mutableDateTime39.isBefore((long) 9);
org.joda.time.Chronology chronology43 = mutableDateTime39.getChronology();
org.joda.time.MutableDateTime mutableDateTime44 = org.joda.time.MutableDateTime.now(chronology43);
org.joda.time.MutableDateTime mutableDateTime45 = new org.joda.time.MutableDateTime(6335532L, chronology43);
org.joda.time.MutableDateTime mutableDateTime46 = mutableDateTime20.toMutableDateTime(chronology43);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime(47, 48, 46004, 787, 365, 263, (int) (short) 0, chronology43);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 787 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:08.444Z" + "'", str11, "2020-11-25T01:49:08.444Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(dateTimeField18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 1 + "'", int19 == 1);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertNotNull(property21);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:08.444Z" + "'", str27, "2020-11-25T01:49:08.444Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 48 + "'", int30 == 48);
org.junit.Assert.assertNotNull(dateTimeZone34);
org.junit.Assert.assertNotNull(dateTime35);
org.junit.Assert.assertNotNull(property40);
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + false + "'", boolean42 == false);
org.junit.Assert.assertNotNull(chronology43);
org.junit.Assert.assertNotNull(mutableDateTime44);
org.junit.Assert.assertNotNull(mutableDateTime46);
}
@Test
@Ignore
public void test1715() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1715");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
int int6 = mutableDateTime3.getYearOfCentury();
org.joda.time.Chronology chronology7 = mutableDateTime3.getChronology();
int int8 = mutableDateTime3.getWeekOfWeekyear();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.DateTimeZone dateTimeZone12 = mutableDateTime11.getZone();
org.joda.time.DateTime dateTime13 = mutableDateTime3.toDateTime(dateTimeZone12);
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((-1L), dateTimeZone12);
org.joda.time.MutableDateTime mutableDateTime15 = mutableDateTime14.toMutableDateTimeISO();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime15.minuteOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property16.roundHalfFloor();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:08.489Z" + "'", str5, "2020-11-25T01:49:08.489Z");
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 20 + "'", int6 == 20);
org.junit.Assert.assertNotNull(chronology7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 48 + "'", int8 == 48);
org.junit.Assert.assertNotNull(dateTimeZone12);
org.junit.Assert.assertNotNull(dateTime13);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(mutableDateTime17);
}
@Test
@Ignore
public void test1716() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1716");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime2.add(readablePeriod6);
int int8 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.setWeekOfWeekyear(26);
int int11 = mutableDateTime2.getMinuteOfDay();
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 4 + "'", int8 == 4);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 0 + "'", int11 == 0);
}
@Test
@Ignore
public void test1717() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1717");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfMonth();
boolean boolean4 = mutableDateTime1.isBefore((long) 9);
org.joda.time.Chronology chronology5 = mutableDateTime1.getChronology();
org.joda.time.MutableDateTime mutableDateTime6 = org.joda.time.MutableDateTime.now(chronology5);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(6335532L, chronology5);
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime7.toMutableDateTime(chronology8);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.secondOfMinute();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
int int16 = mutableDateTime13.getYearOfCentury();
org.joda.time.Chronology chronology17 = mutableDateTime13.getChronology();
int int18 = mutableDateTime13.getWeekOfWeekyear();
int int19 = mutableDateTime13.getCenturyOfEra();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
org.joda.time.ReadablePeriod readablePeriod25 = null;
mutableDateTime22.add(readablePeriod25);
org.joda.time.MutableDateTime.Property property27 = mutableDateTime22.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType28 = property27.getFieldType();
boolean boolean29 = mutableDateTime13.isSupported(dateTimeFieldType28);
int int30 = property10.compareTo((org.joda.time.ReadableInstant) mutableDateTime13);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
org.junit.Assert.assertNotNull(chronology5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:08.594Z" + "'", str15, "2020-11-25T01:49:08.594Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 20 + "'", int16 == 20);
org.junit.Assert.assertNotNull(chronology17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 48 + "'", int18 == 48);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 20 + "'", int19 == 20);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:08.594Z" + "'", str24, "2020-11-25T01:49:08.594Z");
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(dateTimeFieldType28);
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + true + "'", boolean29 == true);
// flaky: org.junit.Assert.assertTrue("'" + int30 + "' != '" + 1 + "'", int30 == 1);
}
@Test
@Ignore
public void test1718() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1718");
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.yearOfCentury();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime9.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime18 = property16.add((long) 48);
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.yearOfCentury();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
org.joda.time.MutableDateTime.Property property28 = mutableDateTime21.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime29 = property28.roundCeiling();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
mutableDateTime32.setTime((long) '#');
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
org.joda.time.format.DateTimeFormatter dateTimeFormatter40 = null;
java.lang.String str41 = mutableDateTime39.toString(dateTimeFormatter40);
org.joda.time.ReadablePeriod readablePeriod42 = null;
mutableDateTime39.add(readablePeriod42);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime39.hourOfDay();
java.lang.String str45 = mutableDateTime39.toString();
int int46 = mutableDateTime32.compareTo((org.joda.time.ReadableInstant) mutableDateTime39);
org.joda.time.MutableDateTime mutableDateTime47 = mutableDateTime32.copy();
java.lang.Object obj48 = null;
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime(obj48, chronology49);
org.joda.time.format.DateTimeFormatter dateTimeFormatter51 = null;
java.lang.String str52 = mutableDateTime50.toString(dateTimeFormatter51);
int int53 = mutableDateTime50.getYearOfCentury();
org.joda.time.Chronology chronology54 = mutableDateTime50.getChronology();
int int55 = mutableDateTime50.getWeekOfWeekyear();
java.lang.Object obj56 = null;
org.joda.time.Chronology chronology57 = null;
org.joda.time.MutableDateTime mutableDateTime58 = new org.joda.time.MutableDateTime(obj56, chronology57);
org.joda.time.DateTimeZone dateTimeZone59 = mutableDateTime58.getZone();
org.joda.time.DateTime dateTime60 = mutableDateTime50.toDateTime(dateTimeZone59);
org.joda.time.DateTimeZone dateTimeZone61 = mutableDateTime50.getZone();
mutableDateTime47.setZoneRetainFields(dateTimeZone61);
org.joda.time.MutableDateTime mutableDateTime63 = mutableDateTime29.toMutableDateTime(dateTimeZone61);
mutableDateTime18.setZoneRetainFields(dateTimeZone61);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime65 = new org.joda.time.MutableDateTime(30, 6423656, 645, 6537, 56942393, 0, 2025, dateTimeZone61);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6537 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:08.655Z" + "'", str11, "2020-11-25T01:49:08.655Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(mutableDateTime18);
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:08.655Z" + "'", str23, "2020-11-25T01:49:08.655Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertNotNull(mutableDateTime29);
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:08.655Z" + "'", str34, "2020-11-25T01:49:08.655Z");
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:08.655Z" + "'", str41, "2020-11-25T01:49:08.655Z");
org.junit.Assert.assertNotNull(property44);
// flaky: org.junit.Assert.assertEquals("'" + str45 + "' != '" + "2020-11-25T01:49:08.655Z" + "'", str45, "2020-11-25T01:49:08.655Z");
org.junit.Assert.assertTrue("'" + int46 + "' != '" + (-1) + "'", int46 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime47);
// flaky: org.junit.Assert.assertEquals("'" + str52 + "' != '" + "2020-11-25T01:49:08.655Z" + "'", str52, "2020-11-25T01:49:08.655Z");
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 20 + "'", int53 == 20);
org.junit.Assert.assertNotNull(chronology54);
org.junit.Assert.assertTrue("'" + int55 + "' != '" + 48 + "'", int55 == 48);
org.junit.Assert.assertNotNull(dateTimeZone59);
org.junit.Assert.assertNotNull(dateTime60);
org.junit.Assert.assertNotNull(dateTimeZone61);
org.junit.Assert.assertNotNull(mutableDateTime63);
}
@Test
@Ignore
public void test1719() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1719");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.DurationField durationField4 = property2.getDurationField();
org.joda.time.MutableDateTime mutableDateTime5 = property2.roundCeiling();
org.joda.time.DurationField durationField6 = property2.getRangeDurationField();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertNotNull(durationField4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNull(durationField6);
}
@Test
@Ignore
public void test1720() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1720");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
org.joda.time.MutableDateTime.Property property4 = mutableDateTime3.dayOfYear();
java.util.GregorianCalendar gregorianCalendar5 = mutableDateTime3.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime3.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime7.dayOfMonth();
int int9 = mutableDateTime7.getCenturyOfEra();
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology11);
mutableDateTime12.setSecondOfMinute((int) '4');
int int15 = mutableDateTime12.getMinuteOfDay();
int int16 = mutableDateTime12.getCenturyOfEra();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
int int20 = mutableDateTime19.getDayOfWeek();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.DateTimeZone dateTimeZone24 = mutableDateTime23.getZone();
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(dateTimeZone24);
mutableDateTime19.setZoneRetainFields(dateTimeZone24);
org.joda.time.DateTime dateTime27 = mutableDateTime12.toDateTime(dateTimeZone24);
mutableDateTime7.setZoneRetainFields(dateTimeZone24);
org.joda.time.MutableDateTime mutableDateTime29 = org.joda.time.MutableDateTime.now(dateTimeZone24);
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime3.toMutableDateTime(dateTimeZone24);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) '#', dateTimeZone24);
org.joda.time.Instant instant32 = mutableDateTime31.toInstant();
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(gregorianCalendar5);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 20 + "'", int9 == 20);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 19 + "'", int16 == 19);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 3 + "'", int20 == 3);
org.junit.Assert.assertNotNull(dateTimeZone24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(dateTime27);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(instant32);
}
@Test
@Ignore
public void test1721() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1721");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.centuryOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.DateTimeZone dateTimeZone14 = mutableDateTime13.getZone();
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone14);
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone14);
mutableDateTime16.setSecondOfMinute((int) (short) 0);
org.joda.time.ReadableDuration readableDuration19 = null;
mutableDateTime16.add(readableDuration19);
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime21.dayOfMonth();
boolean boolean24 = mutableDateTime21.isBefore((long) 9);
org.joda.time.Chronology chronology25 = mutableDateTime21.getChronology();
org.joda.time.MutableDateTime mutableDateTime26 = org.joda.time.MutableDateTime.now(chronology25);
mutableDateTime16.setChronology(chronology25);
mutableDateTime2.setChronology(chronology25);
org.joda.time.ReadablePeriod readablePeriod29 = null;
mutableDateTime2.add(readablePeriod29);
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.format.DateTimeFormatter dateTimeFormatter35 = null;
java.lang.String str36 = mutableDateTime34.toString(dateTimeFormatter35);
org.joda.time.ReadablePeriod readablePeriod37 = null;
mutableDateTime34.add(readablePeriod37);
org.joda.time.MutableDateTime.Property property39 = mutableDateTime34.hourOfDay();
org.joda.time.MutableDateTime.Property property40 = mutableDateTime34.dayOfWeek();
int int41 = property40.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime43 = property40.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime44 = property40.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod45 = null;
mutableDateTime44.add(readablePeriod45, 40);
java.lang.Object obj48 = null;
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime(obj48, chronology49);
org.joda.time.format.DateTimeFormatter dateTimeFormatter51 = null;
java.lang.String str52 = mutableDateTime50.toString(dateTimeFormatter51);
int int53 = mutableDateTime50.getYearOfCentury();
org.joda.time.Chronology chronology54 = mutableDateTime50.getChronology();
org.joda.time.MutableDateTime mutableDateTime55 = mutableDateTime44.toMutableDateTime(chronology54);
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime((long) 100, chronology54);
org.joda.time.MutableDateTime mutableDateTime57 = org.joda.time.MutableDateTime.now(chronology54);
boolean boolean58 = mutableDateTime2.isEqual((org.joda.time.ReadableInstant) mutableDateTime57);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:08.853Z" + "'", str4, "2020-11-25T01:49:08.853Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(dateTimeZone14);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
org.junit.Assert.assertNotNull(chronology25);
org.junit.Assert.assertNotNull(mutableDateTime26);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:08.853Z" + "'", str36, "2020-11-25T01:49:08.853Z");
org.junit.Assert.assertNotNull(property39);
org.junit.Assert.assertNotNull(property40);
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 7 + "'", int41 == 7);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(mutableDateTime44);
// flaky: org.junit.Assert.assertEquals("'" + str52 + "' != '" + "2020-11-25T01:49:08.853Z" + "'", str52, "2020-11-25T01:49:08.853Z");
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 20 + "'", int53 == 20);
org.junit.Assert.assertNotNull(chronology54);
org.junit.Assert.assertNotNull(mutableDateTime55);
org.junit.Assert.assertNotNull(mutableDateTime57);
// flaky: org.junit.Assert.assertTrue("'" + boolean58 + "' != '" + true + "'", boolean58 == true);
}
@Test
@Ignore
public void test1722() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1722");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
mutableDateTime2.setDate((long) 6300);
boolean boolean9 = mutableDateTime2.isBefore((long) (byte) 0);
int int10 = mutableDateTime2.getYearOfCentury();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime2.dayOfWeek();
mutableDateTime2.setWeekyear(366);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 70 + "'", int10 == 70);
org.junit.Assert.assertNotNull(property11);
}
@Test
public void test1723() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1723");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
java.util.GregorianCalendar gregorianCalendar6 = mutableDateTime5.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime8 = mutableDateTime5.copy();
mutableDateTime8.setYear((int) (byte) 0);
org.joda.time.Chronology chronology11 = mutableDateTime8.getChronology();
mutableDateTime8.addHours(981);
boolean boolean14 = mutableDateTime8.isAfterNow();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(gregorianCalendar6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(chronology11);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
}
@Test
@Ignore
public void test1724() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1724");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property15.add(2189);
java.lang.String str18 = mutableDateTime17.toString();
int int19 = mutableDateTime17.getDayOfYear();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime17.dayOfWeek();
java.util.Locale locale21 = null;
java.lang.String str22 = property20.getAsShortText(locale21);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:08.978Z" + "'", str4, "2020-11-25T01:49:08.978Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T02:25:37.978Z" + "'", str18, "2020-11-25T02:25:37.978Z");
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 330 + "'", int19 == 330);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Wed" + "'", str22, "Wed");
}
@Test
@Ignore
public void test1725() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1725");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
int int4 = property3.get();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.format.DateTimeFormatter dateTimeFormatter8 = null;
java.lang.String str9 = mutableDateTime7.toString(dateTimeFormatter8);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime7.add(readablePeriod10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime7.centuryOfEra();
org.joda.time.ReadableInstant readableInstant13 = null;
mutableDateTime7.setDate(readableInstant13);
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime15.dayOfMonth();
int int17 = mutableDateTime15.getCenturyOfEra();
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology19);
mutableDateTime20.setSecondOfMinute((int) '4');
int int23 = mutableDateTime20.getMinuteOfDay();
int int24 = mutableDateTime20.getCenturyOfEra();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
int int28 = mutableDateTime27.getDayOfWeek();
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.DateTimeZone dateTimeZone32 = mutableDateTime31.getZone();
org.joda.time.MutableDateTime mutableDateTime33 = org.joda.time.MutableDateTime.now(dateTimeZone32);
mutableDateTime27.setZoneRetainFields(dateTimeZone32);
org.joda.time.DateTime dateTime35 = mutableDateTime20.toDateTime(dateTimeZone32);
mutableDateTime15.setZoneRetainFields(dateTimeZone32);
mutableDateTime7.setZone(dateTimeZone32);
org.joda.time.MutableDateTime mutableDateTime38 = org.joda.time.MutableDateTime.now(dateTimeZone32);
long long39 = property3.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime38);
int int40 = property3.getMaximumValueOverall();
java.util.Locale locale41 = null;
java.lang.String str42 = property3.getAsShortText(locale41);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:09.021Z" + "'", str9, "2020-11-25T01:49:09.021Z");
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 20 + "'", int17 == 20);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 0 + "'", int23 == 0);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 19 + "'", int24 == 19);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 3 + "'", int28 == 3);
org.junit.Assert.assertNotNull(dateTimeZone32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(dateTime35);
org.junit.Assert.assertNotNull(mutableDateTime38);
org.junit.Assert.assertTrue("'" + long39 + "' != '" + (-18591L) + "'", long39 == (-18591L));
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 366 + "'", int40 == 366);
org.junit.Assert.assertEquals("'" + str42 + "' != '" + "1" + "'", str42, "1");
}
@Test
public void test1726() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1726");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
mutableDateTime9.addDays(19);
int int19 = mutableDateTime9.getCenturyOfEra();
mutableDateTime9.setSecondOfMinute(0);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:09.128Z" + "'", str4, "2020-11-25T01:49:09.128Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:09.128Z" + "'", str11, "2020-11-25T01:49:09.128Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:09.128Z" + "'", str15, "2020-11-25T01:49:09.128Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 20 + "'", int19 == 20);
}
@Test
@Ignore
public void test1727() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1727");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
mutableDateTime2.setMillisOfSecond(7);
mutableDateTime2.setSecondOfDay(442);
org.joda.time.DateTimeField dateTimeField10 = mutableDateTime2.getRoundingField();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:09.175Z" + "'", str4, "2020-11-25T01:49:09.175Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNull(dateTimeField10);
}
@Test
@Ignore
public void test1728() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1728");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
int int6 = mutableDateTime2.getCenturyOfEra();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
int int10 = mutableDateTime9.getDayOfWeek();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.DateTimeZone dateTimeZone14 = mutableDateTime13.getZone();
org.joda.time.MutableDateTime mutableDateTime15 = org.joda.time.MutableDateTime.now(dateTimeZone14);
mutableDateTime9.setZoneRetainFields(dateTimeZone14);
org.joda.time.DateTime dateTime17 = mutableDateTime2.toDateTime(dateTimeZone14);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime2.copy();
mutableDateTime2.setSecondOfDay(981);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 19 + "'", int6 == 19);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 3 + "'", int10 == 3);
org.junit.Assert.assertNotNull(dateTimeZone14);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertNotNull(dateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(mutableDateTime19);
}
@Test
public void test1729() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1729");
java.lang.Object obj2 = null;
org.joda.time.Chronology chronology3 = null;
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime(obj2, chronology3);
org.joda.time.DateTimeZone dateTimeZone5 = mutableDateTime4.getZone();
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone5);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone5);
int int8 = mutableDateTime7.getDayOfWeek();
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime((java.lang.Object) int8);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: No instant converter found for type: java.lang.Integer");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(dateTimeZone5);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 4 + "'", int8 == 4);
}
@Test
@Ignore
public void test1730() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1730");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.MutableDateTime mutableDateTime4 = property2.roundHalfEven();
boolean boolean5 = mutableDateTime4.isAfterNow();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
}
@Test
@Ignore
public void test1731() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1731");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.Interval interval4 = property2.toInterval();
org.joda.time.MutableDateTime mutableDateTime6 = property2.add(336);
org.joda.time.MutableDateTime mutableDateTime7 = property2.roundCeiling();
mutableDateTime7.setDate((long) 6281);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(interval4);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(mutableDateTime7);
}
@Test
public void test1732() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1732");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = property3.roundCeiling();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.Instant instant8 = mutableDateTime7.toInstant();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime7.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime10 = property9.roundHalfFloor();
java.util.GregorianCalendar gregorianCalendar11 = mutableDateTime10.toGregorianCalendar();
int int12 = mutableDateTime10.getMillisOfDay();
mutableDateTime4.setMillis((org.joda.time.ReadableInstant) mutableDateTime10);
mutableDateTime4.setWeekyear(59);
int int16 = mutableDateTime4.getYearOfCentury();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(instant8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(gregorianCalendar11);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 59 + "'", int16 == 59);
}
@Test
@Ignore
public void test1733() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1733");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
int int17 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.MutableDateTime mutableDateTime18 = mutableDateTime11.toMutableDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime11.toMutableDateTimeISO();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
int int25 = mutableDateTime22.getYearOfCentury();
org.joda.time.Chronology chronology26 = mutableDateTime22.getChronology();
mutableDateTime19.setChronology(chronology26);
mutableDateTime19.addYears(100);
boolean boolean31 = mutableDateTime19.isBefore((-18591L));
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.format.DateTimeFormatter dateTimeFormatter35 = null;
java.lang.String str36 = mutableDateTime34.toString(dateTimeFormatter35);
org.joda.time.ReadablePeriod readablePeriod37 = null;
mutableDateTime34.add(readablePeriod37);
org.joda.time.MutableDateTime.Property property39 = mutableDateTime34.hourOfDay();
org.joda.time.MutableDateTime.Property property40 = mutableDateTime34.dayOfWeek();
int int41 = property40.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime43 = property40.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime44 = property40.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod45 = null;
mutableDateTime44.add(readablePeriod45, 40);
java.lang.Object obj48 = null;
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime(obj48, chronology49);
org.joda.time.format.DateTimeFormatter dateTimeFormatter51 = null;
java.lang.String str52 = mutableDateTime50.toString(dateTimeFormatter51);
int int53 = mutableDateTime50.getYearOfCentury();
org.joda.time.Chronology chronology54 = mutableDateTime50.getChronology();
org.joda.time.MutableDateTime mutableDateTime55 = mutableDateTime44.toMutableDateTime(chronology54);
org.joda.time.MutableDateTime mutableDateTime56 = org.joda.time.MutableDateTime.now(chronology54);
org.joda.time.MutableDateTime.Property property57 = mutableDateTime56.dayOfYear();
java.lang.String str58 = property57.getAsString();
long long59 = property57.remainder();
org.joda.time.DurationField durationField60 = property57.getRangeDurationField();
java.util.Locale locale61 = null;
java.lang.String str62 = property57.getAsText(locale61);
org.joda.time.Chronology chronology64 = null;
org.joda.time.MutableDateTime mutableDateTime65 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology64);
org.joda.time.MutableDateTime.Property property66 = mutableDateTime65.dayOfYear();
mutableDateTime65.setMillis((long) 9);
int int69 = property57.getDifference((org.joda.time.ReadableInstant) mutableDateTime65);
org.joda.time.DateTimeField dateTimeField70 = property57.getField();
int int71 = mutableDateTime19.get(dateTimeField70);
org.joda.time.ReadablePeriod readablePeriod72 = null;
mutableDateTime19.add(readablePeriod72);
org.joda.time.DateTimeZone dateTimeZone74 = mutableDateTime19.getZone();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:09.409Z" + "'", str4, "2020-11-25T01:49:09.409Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:09.410Z" + "'", str13, "2020-11-25T01:49:09.410Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 0 + "'", int17 == 0);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:09.410Z" + "'", str24, "2020-11-25T01:49:09.410Z");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 20 + "'", int25 == 20);
org.junit.Assert.assertNotNull(chronology26);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:09.410Z" + "'", str36, "2020-11-25T01:49:09.410Z");
org.junit.Assert.assertNotNull(property39);
org.junit.Assert.assertNotNull(property40);
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 7 + "'", int41 == 7);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(mutableDateTime44);
// flaky: org.junit.Assert.assertEquals("'" + str52 + "' != '" + "2020-11-25T01:49:09.410Z" + "'", str52, "2020-11-25T01:49:09.410Z");
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 20 + "'", int53 == 20);
org.junit.Assert.assertNotNull(chronology54);
org.junit.Assert.assertNotNull(mutableDateTime55);
org.junit.Assert.assertNotNull(mutableDateTime56);
org.junit.Assert.assertNotNull(property57);
org.junit.Assert.assertEquals("'" + str58 + "' != '" + "330" + "'", str58, "330");
// flaky: org.junit.Assert.assertTrue("'" + long59 + "' != '" + 6549410L + "'", long59 == 6549410L);
org.junit.Assert.assertNotNull(durationField60);
org.junit.Assert.assertEquals("'" + str62 + "' != '" + "330" + "'", str62, "330");
org.junit.Assert.assertNotNull(property66);
org.junit.Assert.assertTrue("'" + int69 + "' != '" + 18591 + "'", int69 == 18591);
org.junit.Assert.assertNotNull(dateTimeField70);
org.junit.Assert.assertTrue("'" + int71 + "' != '" + 330 + "'", int71 == 330);
org.junit.Assert.assertNotNull(dateTimeZone74);
}
@Test
public void test1734() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1734");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
mutableDateTime2.add((long) 3);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.monthOfYear();
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime2.toString(dateTimeFormatter13);
mutableDateTime2.addWeekyears((int) (short) 1);
boolean boolean18 = mutableDateTime2.isAfter(10L);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:09.482Z" + "'", str4, "2020-11-25T01:49:09.482Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property12);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:09.485Z" + "'", str14, "2020-11-25T01:49:09.485Z");
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + true + "'", boolean18 == true);
}
@Test
@Ignore
public void test1735() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1735");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
mutableDateTime2.add((long) 3);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.monthOfYear();
int int13 = mutableDateTime2.getYearOfEra();
int int14 = mutableDateTime2.getMillisOfDay();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.format.DateTimeFormatter dateTimeFormatter18 = null;
java.lang.String str19 = mutableDateTime17.toString(dateTimeFormatter18);
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime17.add(readablePeriod20);
org.joda.time.MutableDateTime.Property property22 = mutableDateTime17.yearOfCentury();
boolean boolean23 = mutableDateTime2.isAfter((org.joda.time.ReadableInstant) mutableDateTime17);
mutableDateTime2.addWeeks((int) (byte) 0);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:09.512Z" + "'", str4, "2020-11-25T01:49:09.512Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 2020 + "'", int13 == 2020);
// flaky: org.junit.Assert.assertTrue("'" + int14 + "' != '" + 6549515 + "'", int14 == 6549515);
// flaky: org.junit.Assert.assertEquals("'" + str19 + "' != '" + "2020-11-25T01:49:09.512Z" + "'", str19, "2020-11-25T01:49:09.512Z");
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + true + "'", boolean23 == true);
}
@Test
@Ignore
public void test1736() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1736");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
int int3 = mutableDateTime0.getRoundingMode();
java.lang.Object obj4 = null;
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime(obj4, chronology5);
org.joda.time.DateTimeZone dateTimeZone7 = mutableDateTime6.getZone();
int int8 = mutableDateTime6.getSecondOfMinute();
int int9 = mutableDateTime6.getMonthOfYear();
org.joda.time.Chronology chronology10 = mutableDateTime6.getChronology();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
org.joda.time.ReadablePeriod readablePeriod16 = null;
mutableDateTime13.add(readablePeriod16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.centuryOfEra();
org.joda.time.ReadableInstant readableInstant19 = null;
mutableDateTime13.setDate(readableInstant19);
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime21.dayOfMonth();
int int23 = mutableDateTime21.getCenturyOfEra();
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology25);
mutableDateTime26.setSecondOfMinute((int) '4');
int int29 = mutableDateTime26.getMinuteOfDay();
int int30 = mutableDateTime26.getCenturyOfEra();
java.lang.Object obj31 = null;
org.joda.time.Chronology chronology32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(obj31, chronology32);
int int34 = mutableDateTime33.getDayOfWeek();
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.DateTimeZone dateTimeZone38 = mutableDateTime37.getZone();
org.joda.time.MutableDateTime mutableDateTime39 = org.joda.time.MutableDateTime.now(dateTimeZone38);
mutableDateTime33.setZoneRetainFields(dateTimeZone38);
org.joda.time.DateTime dateTime41 = mutableDateTime26.toDateTime(dateTimeZone38);
mutableDateTime21.setZoneRetainFields(dateTimeZone38);
mutableDateTime13.setZone(dateTimeZone38);
org.joda.time.MutableDateTime mutableDateTime44 = org.joda.time.MutableDateTime.now(dateTimeZone38);
org.joda.time.MutableDateTime mutableDateTime45 = mutableDateTime6.toMutableDateTime(dateTimeZone38);
org.joda.time.MutableDateTime mutableDateTime46 = mutableDateTime0.toMutableDateTime(dateTimeZone38);
org.joda.time.MutableDateTime.Property property47 = mutableDateTime46.minuteOfHour();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertNotNull(dateTimeZone7);
// flaky: org.junit.Assert.assertTrue("'" + int8 + "' != '" + 9 + "'", int8 == 9);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 11 + "'", int9 == 11);
org.junit.Assert.assertNotNull(chronology10);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:09.621Z" + "'", str15, "2020-11-25T01:49:09.621Z");
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 0 + "'", int29 == 0);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 19 + "'", int30 == 19);
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 3 + "'", int34 == 3);
org.junit.Assert.assertNotNull(dateTimeZone38);
org.junit.Assert.assertNotNull(mutableDateTime39);
org.junit.Assert.assertNotNull(dateTime41);
org.junit.Assert.assertNotNull(mutableDateTime44);
org.junit.Assert.assertNotNull(mutableDateTime45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertNotNull(property47);
}
@Test
@Ignore
public void test1737() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1737");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime23.toMutableDateTimeISO();
// The following exception was thrown during execution in test generation
try {
mutableDateTime23.setMinuteOfDay((-292275054));
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value -292275054 for minuteOfDay must be in the range [0,1439]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:09.697Z" + "'", str4, "2020-11-25T01:49:09.697Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:09.697Z" + "'", str20, "2020-11-25T01:49:09.697Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
}
@Test
@Ignore
public void test1738() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1738");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
mutableDateTime2.setMinuteOfDay(4);
java.lang.Object obj6 = null;
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime(obj6, chronology7);
org.joda.time.format.DateTimeFormatter dateTimeFormatter9 = null;
java.lang.String str10 = mutableDateTime8.toString(dateTimeFormatter9);
int int11 = mutableDateTime8.getYearOfCentury();
org.joda.time.Chronology chronology12 = mutableDateTime8.getChronology();
int int13 = mutableDateTime8.getWeekOfWeekyear();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.DateTimeZone dateTimeZone17 = mutableDateTime16.getZone();
org.joda.time.DateTime dateTime18 = mutableDateTime8.toDateTime(dateTimeZone17);
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime2.toMutableDateTime(dateTimeZone17);
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(dateTimeZone17);
java.lang.Object obj21 = mutableDateTime20.clone();
int int22 = mutableDateTime20.getHourOfDay();
mutableDateTime20.addWeeks(6423656);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime20.centuryOfEra();
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertEquals("'" + str10 + "' != '" + "2020-11-25T01:49:09.731Z" + "'", str10, "2020-11-25T01:49:09.731Z");
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 20 + "'", int11 == 20);
org.junit.Assert.assertNotNull(chronology12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 48 + "'", int13 == 48);
org.junit.Assert.assertNotNull(dateTimeZone17);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(obj21);
// flaky: org.junit.Assert.assertEquals(obj21.toString(), "2020-11-25T01:49:09.731Z");
// flaky: org.junit.Assert.assertEquals(java.lang.String.valueOf(obj21), "2020-11-25T01:49:09.731Z");
// flaky: org.junit.Assert.assertEquals(java.util.Objects.toString(obj21), "2020-11-25T01:49:09.731Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 1 + "'", int22 == 1);
org.junit.Assert.assertNotNull(property25);
}
@Test
@Ignore
public void test1739() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1739");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property3.add((long) (short) -1);
java.util.Locale locale6 = null;
int int7 = property3.getMaximumShortTextLength(locale6);
long long8 = property3.remainder();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.Instant instant12 = mutableDateTime11.toInstant();
mutableDateTime11.setSecondOfDay((int) '#');
mutableDateTime11.setTime((int) (short) 10, (int) '#', 49, (int) (byte) 10);
int int20 = mutableDateTime11.getMillisOfSecond();
int int21 = property3.compareTo((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.MutableDateTime mutableDateTime22 = property3.roundCeiling();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.secondOfDay();
org.joda.time.ReadableDuration readableDuration24 = null;
mutableDateTime22.add(readableDuration24);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 3 + "'", int7 == 3);
org.junit.Assert.assertTrue("'" + long8 + "' != '" + 1L + "'", long8 == 1L);
org.junit.Assert.assertNotNull(instant12);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 10 + "'", int20 == 10);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 1 + "'", int21 == 1);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(property23);
}
@Test
public void test1740() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1740");
org.joda.time.MutableDateTime mutableDateTime1 = org.joda.time.MutableDateTime.parse("2020-11-25T01:47:30.683Z");
// The following exception was thrown during execution in test generation
try {
mutableDateTime1.setDayOfWeek(38149);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 38149 for dayOfWeek must be in the range [1,7]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(mutableDateTime1);
}
@Test
@Ignore
public void test1741() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1741");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
org.joda.time.MutableDateTime mutableDateTime33 = property2.roundFloor();
org.joda.time.MutableDateTime mutableDateTime35 = property2.addWrapField(2020);
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
int int41 = mutableDateTime38.getYearOfCentury();
org.joda.time.Chronology chronology42 = mutableDateTime38.getChronology();
int int43 = mutableDateTime38.getWeekOfWeekyear();
java.lang.Object obj44 = null;
org.joda.time.Chronology chronology45 = null;
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime(obj44, chronology45);
org.joda.time.DateTimeZone dateTimeZone47 = mutableDateTime46.getZone();
org.joda.time.DateTime dateTime48 = mutableDateTime38.toDateTime(dateTimeZone47);
org.joda.time.MutableDateTime mutableDateTime49 = mutableDateTime38.copy();
boolean boolean50 = mutableDateTime38.isAfterNow();
org.joda.time.MutableDateTime.Property property51 = mutableDateTime38.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime53 = property51.add(2189);
java.lang.Object obj54 = null;
org.joda.time.Chronology chronology55 = null;
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime(obj54, chronology55);
org.joda.time.format.DateTimeFormatter dateTimeFormatter57 = null;
java.lang.String str58 = mutableDateTime56.toString(dateTimeFormatter57);
org.joda.time.ReadablePeriod readablePeriod59 = null;
mutableDateTime56.add(readablePeriod59);
org.joda.time.MutableDateTime.Property property61 = mutableDateTime56.hourOfDay();
org.joda.time.MutableDateTime.Property property62 = mutableDateTime56.dayOfWeek();
org.joda.time.DurationField durationField63 = property62.getRangeDurationField();
java.lang.String str64 = property62.getName();
org.joda.time.DateTimeFieldType dateTimeFieldType65 = property62.getFieldType();
boolean boolean66 = mutableDateTime53.isSupported(dateTimeFieldType65);
org.joda.time.MutableDateTime.Property property67 = mutableDateTime35.property(dateTimeFieldType65);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:09.917Z" + "'", str13, "2020-11-25T01:49:09.917Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:09.917Z" + "'", str27, "2020-11-25T01:49:09.917Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(mutableDateTime35);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:09.917Z" + "'", str40, "2020-11-25T01:49:09.917Z");
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 20 + "'", int41 == 20);
org.junit.Assert.assertNotNull(chronology42);
org.junit.Assert.assertTrue("'" + int43 + "' != '" + 48 + "'", int43 == 48);
org.junit.Assert.assertNotNull(dateTimeZone47);
org.junit.Assert.assertNotNull(dateTime48);
org.junit.Assert.assertNotNull(mutableDateTime49);
org.junit.Assert.assertTrue("'" + boolean50 + "' != '" + false + "'", boolean50 == false);
org.junit.Assert.assertNotNull(property51);
org.junit.Assert.assertNotNull(mutableDateTime53);
// flaky: org.junit.Assert.assertEquals("'" + str58 + "' != '" + "2020-11-25T01:49:09.917Z" + "'", str58, "2020-11-25T01:49:09.917Z");
org.junit.Assert.assertNotNull(property61);
org.junit.Assert.assertNotNull(property62);
org.junit.Assert.assertNotNull(durationField63);
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "dayOfWeek" + "'", str64, "dayOfWeek");
org.junit.Assert.assertNotNull(dateTimeFieldType65);
org.junit.Assert.assertTrue("'" + boolean66 + "' != '" + true + "'", boolean66 == true);
org.junit.Assert.assertNotNull(property67);
}
@Test
public void test1742() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1742");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
org.joda.time.DurationField durationField10 = property8.getDurationField();
org.joda.time.DateTimeField dateTimeField11 = property8.getField();
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime13 = property8.getMutableDateTime();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.011Z" + "'", str4, "2020-11-25T01:49:10.011Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertNotNull(dateTimeField11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
}
@Test
public void test1743() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1743");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
boolean boolean9 = property8.isLeap();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.048Z" + "'", str4, "2020-11-25T01:49:10.048Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
}
@Test
public void test1744() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1744");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
org.joda.time.ReadablePeriod readablePeriod3 = null;
mutableDateTime1.add(readablePeriod3);
org.junit.Assert.assertNotNull(property2);
}
@Test
@Ignore
public void test1745() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1745");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.year();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
mutableDateTime2.setChronology(chronology29);
java.lang.Object obj32 = mutableDateTime2.clone();
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property34 = mutableDateTime33.dayOfMonth();
int int35 = mutableDateTime33.getCenturyOfEra();
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology37);
mutableDateTime38.setSecondOfMinute((int) '4');
int int41 = mutableDateTime38.getMinuteOfDay();
int int42 = mutableDateTime38.getCenturyOfEra();
java.lang.Object obj43 = null;
org.joda.time.Chronology chronology44 = null;
org.joda.time.MutableDateTime mutableDateTime45 = new org.joda.time.MutableDateTime(obj43, chronology44);
int int46 = mutableDateTime45.getDayOfWeek();
java.lang.Object obj47 = null;
org.joda.time.Chronology chronology48 = null;
org.joda.time.MutableDateTime mutableDateTime49 = new org.joda.time.MutableDateTime(obj47, chronology48);
org.joda.time.DateTimeZone dateTimeZone50 = mutableDateTime49.getZone();
org.joda.time.MutableDateTime mutableDateTime51 = org.joda.time.MutableDateTime.now(dateTimeZone50);
mutableDateTime45.setZoneRetainFields(dateTimeZone50);
org.joda.time.DateTime dateTime53 = mutableDateTime38.toDateTime(dateTimeZone50);
mutableDateTime33.setZoneRetainFields(dateTimeZone50);
org.joda.time.MutableDateTime mutableDateTime55 = new org.joda.time.MutableDateTime(dateTimeZone50);
org.joda.time.DateTime dateTime56 = mutableDateTime2.toDateTime(dateTimeZone50);
boolean boolean58 = dateTime56.isBefore(50L);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property6);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:10.112Z" + "'", str11, "2020-11-25T01:49:10.112Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:10.112Z" + "'", str27, "2020-11-25T01:49:10.112Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(obj32);
org.junit.Assert.assertEquals(obj32.toString(), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj32), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj32), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertNotNull(property34);
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 20 + "'", int35 == 20);
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 0 + "'", int41 == 0);
org.junit.Assert.assertTrue("'" + int42 + "' != '" + 19 + "'", int42 == 19);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 3 + "'", int46 == 3);
org.junit.Assert.assertNotNull(dateTimeZone50);
org.junit.Assert.assertNotNull(mutableDateTime51);
org.junit.Assert.assertNotNull(dateTime53);
org.junit.Assert.assertNotNull(dateTime56);
org.junit.Assert.assertTrue("'" + boolean58 + "' != '" + false + "'", boolean58 == false);
}
@Test
@Ignore
public void test1746() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1746");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime14 = property9.roundHalfFloor();
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology16);
mutableDateTime17.setSecondOfMinute((int) '4');
int int20 = mutableDateTime17.getMinuteOfDay();
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.format.DateTimeFormatter dateTimeFormatter25 = null;
java.lang.String str26 = mutableDateTime24.toString(dateTimeFormatter25);
org.joda.time.ReadablePeriod readablePeriod27 = null;
mutableDateTime24.add(readablePeriod27);
org.joda.time.MutableDateTime.Property property29 = mutableDateTime24.centuryOfEra();
org.joda.time.DateTimeField dateTimeField30 = property29.getField();
java.lang.Object obj31 = null;
org.joda.time.Chronology chronology32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(obj31, chronology32);
org.joda.time.format.DateTimeFormatter dateTimeFormatter34 = null;
java.lang.String str35 = mutableDateTime33.toString(dateTimeFormatter34);
org.joda.time.ReadablePeriod readablePeriod36 = null;
mutableDateTime33.add(readablePeriod36);
org.joda.time.MutableDateTime.Property property38 = mutableDateTime33.centuryOfEra();
int int39 = property29.getDifference((org.joda.time.ReadableInstant) mutableDateTime33);
org.joda.time.MutableDateTime mutableDateTime40 = mutableDateTime33.toMutableDateTimeISO();
java.lang.Object obj41 = null;
org.joda.time.Chronology chronology42 = null;
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime(obj41, chronology42);
org.joda.time.DateTimeZone dateTimeZone44 = mutableDateTime43.getZone();
org.joda.time.MutableDateTime mutableDateTime45 = mutableDateTime40.toMutableDateTime(dateTimeZone44);
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime((long) 815, dateTimeZone44);
mutableDateTime17.setZoneRetainFields(dateTimeZone44);
org.joda.time.MutableDateTime mutableDateTime48 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime14, dateTimeZone44);
org.joda.time.MutableDateTime mutableDateTime49 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:46:22.334Z", dateTimeZone44);
mutableDateTime49.setWeekyear(0);
org.joda.time.ReadablePeriod readablePeriod52 = null;
mutableDateTime49.add(readablePeriod52);
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:10.173Z" + "'", str5, "2020-11-25T01:49:10.173Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(mutableDateTime14);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 0 + "'", int20 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:10.173Z" + "'", str26, "2020-11-25T01:49:10.173Z");
org.junit.Assert.assertNotNull(property29);
org.junit.Assert.assertNotNull(dateTimeField30);
// flaky: org.junit.Assert.assertEquals("'" + str35 + "' != '" + "2020-11-25T01:49:10.173Z" + "'", str35, "2020-11-25T01:49:10.173Z");
org.junit.Assert.assertNotNull(property38);
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 0 + "'", int39 == 0);
org.junit.Assert.assertNotNull(mutableDateTime40);
org.junit.Assert.assertNotNull(dateTimeZone44);
org.junit.Assert.assertNotNull(mutableDateTime45);
}
@Test
public void test1747() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1747");
org.joda.time.DateTimeZone dateTimeZone0 = null;
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime(dateTimeZone0);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfYear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.format.DateTimeFormatter dateTimeFormatter6 = null;
java.lang.String str7 = mutableDateTime5.toString(dateTimeFormatter6);
org.joda.time.ReadablePeriod readablePeriod8 = null;
mutableDateTime5.add(readablePeriod8);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime5.hourOfDay();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime5.dayOfWeek();
int int12 = property11.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime13 = property11.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime13.dayOfYear();
int int15 = mutableDateTime13.getSecondOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime13.dayOfYear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime19.add(readablePeriod22);
org.joda.time.MutableDateTime.Property property24 = mutableDateTime19.hourOfDay();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime19.dayOfWeek();
org.joda.time.DurationField durationField26 = property25.getRangeDurationField();
java.util.Locale locale27 = null;
int int28 = property25.getMaximumShortTextLength(locale27);
org.joda.time.MutableDateTime mutableDateTime30 = property25.addWrapField((int) (short) 1);
org.joda.time.MutableDateTime.Property property31 = mutableDateTime30.centuryOfEra();
boolean boolean32 = mutableDateTime13.isEqual((org.joda.time.ReadableInstant) mutableDateTime30);
mutableDateTime1.setMillis((org.joda.time.ReadableInstant) mutableDateTime30);
org.joda.time.ReadablePeriod readablePeriod34 = null;
mutableDateTime1.add(readablePeriod34, 366);
org.junit.Assert.assertNotNull(property2);
// flaky: org.junit.Assert.assertEquals("'" + str7 + "' != '" + "2020-11-25T01:49:10.234Z" + "'", str7, "2020-11-25T01:49:10.234Z");
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 7 + "'", int12 == 7);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
org.junit.Assert.assertNotNull(property16);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:10.234Z" + "'", str21, "2020-11-25T01:49:10.234Z");
org.junit.Assert.assertNotNull(property24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertNotNull(durationField26);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 3 + "'", int28 == 3);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(property31);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
}
@Test
@Ignore
public void test1748() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1748");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime2.dayOfYear();
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime14.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime17 = property15.add((long) (short) -1);
java.util.Locale locale18 = null;
int int19 = property15.getMaximumShortTextLength(locale18);
long long20 = property15.remainder();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.Instant instant24 = mutableDateTime23.toInstant();
mutableDateTime23.setSecondOfDay((int) '#');
mutableDateTime23.setTime((int) (short) 10, (int) '#', 49, (int) (byte) 10);
int int32 = mutableDateTime23.getMillisOfSecond();
int int33 = property15.compareTo((org.joda.time.ReadableInstant) mutableDateTime23);
org.joda.time.Chronology chronology34 = mutableDateTime23.getChronology();
int int35 = property11.compareTo((org.joda.time.ReadableInstant) mutableDateTime23);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.310Z" + "'", str4, "2020-11-25T01:49:10.310Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 3 + "'", int19 == 3);
org.junit.Assert.assertTrue("'" + long20 + "' != '" + 1L + "'", long20 == 1L);
org.junit.Assert.assertNotNull(instant24);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 10 + "'", int32 == 10);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 1 + "'", int33 == 1);
org.junit.Assert.assertNotNull(chronology34);
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 0 + "'", int35 == 0);
}
@Test
public void test1749() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1749");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.year();
int int7 = property6.getMinimumValueOverall();
int int8 = property6.get();
org.joda.time.MutableDateTime mutableDateTime10 = property6.addWrapField(26);
mutableDateTime10.addDays(6465511);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + (-292275054) + "'", int7 == (-292275054));
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 1970 + "'", int8 == 1970);
org.junit.Assert.assertNotNull(mutableDateTime10);
}
@Test
public void test1750() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1750");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.add((long) (byte) 1);
mutableDateTime2.addYears(6444);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
}
@Test
@Ignore
public void test1751() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1751");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
mutableDateTime6.setMillis((long) (-1));
int int9 = mutableDateTime6.getDayOfYear();
int int10 = mutableDateTime6.getDayOfYear();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime6.secondOfDay();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 365 + "'", int9 == 365);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 365 + "'", int10 == 365);
org.junit.Assert.assertNotNull(property11);
}
@Test
@Ignore
public void test1752() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1752");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
mutableDateTime2.addDays(0);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime2.minuteOfHour();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.522Z" + "'", str4, "2020-11-25T01:49:10.522Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(property10);
}
@Test
@Ignore
public void test1753() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1753");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
int int13 = mutableDateTime10.getYearOfCentury();
org.joda.time.Chronology chronology14 = mutableDateTime10.getChronology();
org.joda.time.MutableDateTime mutableDateTime15 = mutableDateTime2.toMutableDateTime(chronology14);
java.util.Date date16 = mutableDateTime2.toDate();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.572Z" + "'", str4, "2020-11-25T01:49:10.572Z");
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:10.572Z" + "'", str12, "2020-11-25T01:49:10.572Z");
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 20 + "'", int13 == 20);
org.junit.Assert.assertNotNull(chronology14);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertNotNull(date16);
// flaky: org.junit.Assert.assertEquals(date16.toString(), "Wed Nov 25 01:49:10 UTC 2020");
}
@Test
public void test1754() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1754");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.year();
mutableDateTime2.setMillisOfSecond(14);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.dayOfWeek();
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property9);
}
@Test
@Ignore
public void test1755() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1755");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime2.toMutableDateTime();
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setMinuteOfHour(493);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 493 for minuteOfHour must be in the range [0,59]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(mutableDateTime9);
}
@Test
public void test1756() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1756");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
int int8 = property7.get();
org.joda.time.MutableDateTime mutableDateTime10 = property7.addWrapField(6300);
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
org.joda.time.ReadablePeriod readablePeriod16 = null;
mutableDateTime13.add(readablePeriod16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType19 = property18.getFieldType();
org.joda.time.DateTimeFieldType dateTimeFieldType20 = property18.getFieldType();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime10.property(dateTimeFieldType20);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.643Z" + "'", str4, "2020-11-25T01:49:10.643Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(mutableDateTime10);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:10.643Z" + "'", str15, "2020-11-25T01:49:10.643Z");
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeFieldType19);
org.junit.Assert.assertNotNull(dateTimeFieldType20);
org.junit.Assert.assertNotNull(property21);
}
@Test
@Ignore
public void test1757() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1757");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
int int6 = mutableDateTime2.getMonthOfYear();
int int7 = mutableDateTime2.getHourOfDay();
mutableDateTime2.addSeconds(6382);
mutableDateTime2.setMillisOfDay(2400000);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 11 + "'", int6 == 11);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
}
@Test
@Ignore
public void test1758() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1758");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
org.joda.time.MutableDateTime mutableDateTime33 = property2.roundHalfCeiling();
java.lang.String str34 = mutableDateTime33.toString();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:10.711Z" + "'", str13, "2020-11-25T01:49:10.711Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:10.711Z" + "'", str27, "2020-11-25T01:49:10.711Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertEquals("'" + str34 + "' != '" + "1969-12-29T00:00:00.000Z" + "'", str34, "1969-12-29T00:00:00.000Z");
}
@Test
@Ignore
public void test1759() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1759");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
org.joda.time.DateTimeZone dateTimeZone7 = mutableDateTime2.getZone();
int int8 = mutableDateTime2.getYearOfCentury();
mutableDateTime2.setSecondOfDay(7);
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setTime((-292275054), 105, 6428357, 6330255);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value -292275054 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(dateTimeZone7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
}
@Test
@Ignore
public void test1760() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1760");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
mutableDateTime2.setMinuteOfHour(0);
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
int int15 = mutableDateTime12.getYearOfCentury();
org.joda.time.Chronology chronology16 = mutableDateTime12.getChronology();
int int17 = mutableDateTime12.getWeekOfWeekyear();
boolean boolean18 = mutableDateTime2.isBefore((org.joda.time.ReadableInstant) mutableDateTime12);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime12.yearOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.785Z" + "'", str4, "2020-11-25T01:49:10.785Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:10.785Z" + "'", str14, "2020-11-25T01:49:10.785Z");
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 20 + "'", int15 == 20);
org.junit.Assert.assertNotNull(chronology16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 48 + "'", int17 == 48);
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + true + "'", boolean18 == true);
org.junit.Assert.assertNotNull(property19);
}
@Test
@Ignore
public void test1761() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1761");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.Interval interval4 = property2.toInterval();
org.joda.time.MutableDateTime mutableDateTime6 = property2.add(336);
org.joda.time.MutableDateTime mutableDateTime7 = property2.roundCeiling();
java.lang.Object obj8 = mutableDateTime7.clone();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(interval4);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(obj8);
org.junit.Assert.assertEquals(obj8.toString(), "2021-10-28T00:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj8), "2021-10-28T00:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj8), "2021-10-28T00:00:00.000Z");
}
@Test
public void test1762() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1762");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.secondOfMinute();
int int8 = property7.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
java.util.Locale locale10 = null;
int int11 = property7.getMaximumTextLength(locale10);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 59 + "'", int8 == 59);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 2 + "'", int11 == 2);
}
@Test
@Ignore
public void test1763() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1763");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
int int4 = property3.get();
org.joda.time.DurationField durationField5 = property3.getRangeDurationField();
int int6 = property3.getMaximumValueOverall();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
mutableDateTime9.setTime((long) '#');
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.hourOfDay();
java.lang.String str22 = mutableDateTime16.toString();
int int23 = mutableDateTime9.compareTo((org.joda.time.ReadableInstant) mutableDateTime16);
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime9.copy();
java.lang.String str25 = mutableDateTime9.toString();
mutableDateTime9.addDays(6414);
int int28 = property3.getDifference((org.joda.time.ReadableInstant) mutableDateTime9);
java.lang.String str29 = property3.getAsString();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
org.junit.Assert.assertNotNull(durationField5);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 366 + "'", int6 == 366);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:10.949Z" + "'", str11, "2020-11-25T01:49:10.949Z");
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:10.950Z" + "'", str18, "2020-11-25T01:49:10.950Z");
org.junit.Assert.assertNotNull(property21);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:10.950Z" + "'", str22, "2020-11-25T01:49:10.950Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + (-1) + "'", int23 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T00:00:00.035Z" + "'", str25, "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + (-25005) + "'", int28 == (-25005));
org.junit.Assert.assertEquals("'" + str29 + "' != '" + "1" + "'", str29, "1");
}
@Test
@Ignore
public void test1764() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1764");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
org.joda.time.MutableDateTime mutableDateTime24 = org.joda.time.MutableDateTime.now(chronology22);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfYear();
boolean boolean26 = mutableDateTime24.isEqualNow();
// The following exception was thrown during execution in test generation
try {
mutableDateTime24.setHourOfDay(470);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 470 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:10.993Z" + "'", str4, "2020-11-25T01:49:10.993Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:10.993Z" + "'", str20, "2020-11-25T01:49:10.993Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + true + "'", boolean26 == true);
}
@Test
@Ignore
public void test1765() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1765");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
int int6 = mutableDateTime3.getMinuteOfDay();
int int7 = mutableDateTime3.getCenturyOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
org.joda.time.MutableDateTime mutableDateTime16 = org.joda.time.MutableDateTime.now(dateTimeZone15);
mutableDateTime10.setZoneRetainFields(dateTimeZone15);
org.joda.time.DateTime dateTime18 = mutableDateTime3.toDateTime(dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(259200010L, dateTimeZone15);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime19.dayOfYear();
int int21 = mutableDateTime19.getDayOfWeek();
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.dayOfMonth();
int int24 = mutableDateTime22.getCenturyOfEra();
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology26);
mutableDateTime27.setSecondOfMinute((int) '4');
int int30 = mutableDateTime27.getMinuteOfDay();
int int31 = mutableDateTime27.getCenturyOfEra();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
int int35 = mutableDateTime34.getDayOfWeek();
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.DateTimeZone dateTimeZone39 = mutableDateTime38.getZone();
org.joda.time.MutableDateTime mutableDateTime40 = org.joda.time.MutableDateTime.now(dateTimeZone39);
mutableDateTime34.setZoneRetainFields(dateTimeZone39);
org.joda.time.DateTime dateTime42 = mutableDateTime27.toDateTime(dateTimeZone39);
mutableDateTime22.setZoneRetainFields(dateTimeZone39);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(dateTimeZone39);
org.joda.time.DateTime dateTime45 = mutableDateTime19.toDateTime(dateTimeZone39);
mutableDateTime19.addWeekyears(286086);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 0 + "'", int6 == 0);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 19 + "'", int7 == 19);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 7 + "'", int21 == 7);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 20 + "'", int24 == 20);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 0 + "'", int30 == 0);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 19 + "'", int31 == 19);
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 3 + "'", int35 == 3);
org.junit.Assert.assertNotNull(dateTimeZone39);
org.junit.Assert.assertNotNull(mutableDateTime40);
org.junit.Assert.assertNotNull(dateTime42);
org.junit.Assert.assertNotNull(dateTime45);
}
@Test
public void test1766() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1766");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
java.lang.String str10 = property8.getName();
org.joda.time.MutableDateTime mutableDateTime11 = property8.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime13 = property8.addWrapField(3);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime13.millisOfDay();
boolean boolean16 = mutableDateTime13.isEqual((long) 104);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.146Z" + "'", str4, "2020-11-25T01:49:11.146Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "dayOfWeek" + "'", str10, "dayOfWeek");
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
}
@Test
public void test1767() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1767");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
int int17 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.MutableDateTime mutableDateTime18 = mutableDateTime11.toMutableDateTimeISO();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.DateTimeZone dateTimeZone22 = mutableDateTime21.getZone();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime18.toMutableDateTime(dateTimeZone22);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(dateTimeZone22);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.177Z" + "'", str4, "2020-11-25T01:49:11.177Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:11.177Z" + "'", str13, "2020-11-25T01:49:11.177Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 0 + "'", int17 == 0);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(dateTimeZone22);
org.junit.Assert.assertNotNull(mutableDateTime23);
}
@Test
public void test1768() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1768");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.Instant instant4 = mutableDateTime3.toInstant();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime3.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime6 = property5.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime7 = mutableDateTime6.toMutableDateTime();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime6.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime10 = property8.set(49);
org.joda.time.DurationField durationField11 = property8.getDurationField();
org.joda.time.DateTimeField dateTimeField12 = property8.getField();
org.joda.time.MutableDateTime mutableDateTime13 = property8.roundCeiling();
mutableDateTime13.setDayOfYear(5);
org.joda.time.Chronology chronology16 = mutableDateTime13.getChronology();
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:46:00.410Z", chronology16);
mutableDateTime17.addWeekyears(376);
org.junit.Assert.assertNotNull(instant4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(durationField11);
org.junit.Assert.assertNotNull(dateTimeField12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(chronology16);
}
@Test
@Ignore
public void test1769() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1769");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.secondOfMinute();
org.joda.time.ReadableDuration readableDuration11 = null;
mutableDateTime9.add(readableDuration11, 10);
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.hourOfDay();
java.lang.String str22 = mutableDateTime16.toString();
mutableDateTime16.setSecondOfDay(2);
int int25 = mutableDateTime16.getDayOfWeek();
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.format.DateTimeFormatter dateTimeFormatter29 = null;
java.lang.String str30 = mutableDateTime28.toString(dateTimeFormatter29);
org.joda.time.ReadablePeriod readablePeriod31 = null;
mutableDateTime28.add(readablePeriod31);
org.joda.time.MutableDateTime.Property property33 = mutableDateTime28.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType34 = property33.getFieldType();
boolean boolean35 = mutableDateTime16.isSupported(dateTimeFieldType34);
int int36 = mutableDateTime9.get(dateTimeFieldType34);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.241Z" + "'", str4, "2020-11-25T01:49:11.241Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:11.241Z" + "'", str18, "2020-11-25T01:49:11.241Z");
org.junit.Assert.assertNotNull(property21);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:11.241Z" + "'", str22, "2020-11-25T01:49:11.241Z");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 3 + "'", int25 == 3);
// flaky: org.junit.Assert.assertEquals("'" + str30 + "' != '" + "2020-11-25T01:49:11.241Z" + "'", str30, "2020-11-25T01:49:11.241Z");
org.junit.Assert.assertNotNull(property33);
org.junit.Assert.assertNotNull(dateTimeFieldType34);
org.junit.Assert.assertTrue("'" + boolean35 + "' != '" + true + "'", boolean35 == true);
org.junit.Assert.assertTrue("'" + int36 + "' != '" + 0 + "'", int36 == 0);
}
@Test
public void test1770() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1770");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
org.joda.time.DateTimeField dateTimeField19 = property18.getField();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime23 = property18.addWrapField((int) (short) 10);
mutableDateTime23.setDate(6300, 1, 28);
boolean boolean29 = mutableDateTime23.isBefore((long) 50);
int int30 = mutableDateTime23.getMillisOfSecond();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.279Z" + "'", str4, "2020-11-25T01:49:11.279Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:11.279Z" + "'", str11, "2020-11-25T01:49:11.279Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:11.279Z" + "'", str15, "2020-11-25T01:49:11.279Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeField19);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + false + "'", boolean29 == false);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 35 + "'", int30 == 35);
}
@Test
public void test1771() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1771");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
boolean boolean10 = mutableDateTime9.isEqualNow();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime9.dayOfMonth();
org.joda.time.DurationField durationField12 = property11.getRangeDurationField();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(durationField12);
}
@Test
@Ignore
public void test1772() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1772");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime13 = property11.add((long) (short) -1);
mutableDateTime13.setWeekOfWeekyear((int) '4');
mutableDateTime7.setTime((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.secondOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.dayOfWeek();
int int19 = property18.getMaximumValue();
java.lang.String str20 = property18.getName();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.355Z" + "'", str4, "2020-11-25T01:49:11.355Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 7 + "'", int19 == 7);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "dayOfWeek" + "'", str20, "dayOfWeek");
}
@Test
public void test1773() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1773");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
org.joda.time.MutableDateTime mutableDateTime10 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.minuteOfDay();
org.joda.time.MutableDateTime mutableDateTime13 = property11.set(46);
java.util.Locale locale15 = null;
// The following exception was thrown during execution in test generation
try {
java.lang.String str16 = mutableDateTime13.toString("2020-11-25T01:46:56.863Z", locale15);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal pattern component: T");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
}
@Test
public void test1774() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1774");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.Instant instant8 = mutableDateTime7.toInstant();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime7.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime10 = property9.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime11 = mutableDateTime10.toMutableDateTime();
mutableDateTime2.setDate((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.DateTimeField dateTimeField13 = mutableDateTime11.getRoundingField();
mutableDateTime11.addSeconds(41);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(instant8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNull(dateTimeField13);
}
@Test
public void test1775() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1775");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime10 = property7.add(105);
org.joda.time.MutableDateTime mutableDateTime11 = property7.roundFloor();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.450Z" + "'", str4, "2020-11-25T01:49:11.450Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
@Test
@Ignore
public void test1776() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1776");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime13 = property11.add((long) (short) -1);
mutableDateTime13.setWeekOfWeekyear((int) '4');
mutableDateTime7.setTime((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.secondOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.secondOfMinute();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.yearOfCentury();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
org.joda.time.DateTimeFieldType dateTimeFieldType28 = property27.getFieldType();
int int29 = mutableDateTime13.get(dateTimeFieldType28);
int int30 = mutableDateTime13.getDayOfYear();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.504Z" + "'", str4, "2020-11-25T01:49:11.504Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:11.504Z" + "'", str23, "2020-11-25T01:49:11.504Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(dateTimeFieldType28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 3 + "'", int29 == 3);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 357 + "'", int30 == 357);
}
@Test
@Ignore
public void test1777() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1777");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
mutableDateTime3.setMinuteOfDay(4);
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
int int12 = mutableDateTime9.getYearOfCentury();
org.joda.time.Chronology chronology13 = mutableDateTime9.getChronology();
int int14 = mutableDateTime9.getWeekOfWeekyear();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.DateTime dateTime19 = mutableDateTime9.toDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime3.toMutableDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone18);
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.format.DateTimeFormatter dateTimeFormatter25 = null;
java.lang.String str26 = mutableDateTime24.toString(dateTimeFormatter25);
org.joda.time.ReadablePeriod readablePeriod27 = null;
mutableDateTime24.add(readablePeriod27);
org.joda.time.MutableDateTime.Property property29 = mutableDateTime24.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType30 = property29.getFieldType();
boolean boolean31 = mutableDateTime21.isSupported(dateTimeFieldType30);
mutableDateTime21.setWeekyear((int) (short) 100);
int int34 = mutableDateTime21.getYearOfCentury();
org.junit.Assert.assertNotNull(dateTimeZone4);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:11.535Z" + "'", str11, "2020-11-25T01:49:11.535Z");
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 20 + "'", int12 == 20);
org.junit.Assert.assertNotNull(chronology13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 48 + "'", int14 == 48);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(dateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:11.535Z" + "'", str26, "2020-11-25T01:49:11.535Z");
org.junit.Assert.assertNotNull(property29);
org.junit.Assert.assertNotNull(dateTimeFieldType30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + true + "'", boolean31 == true);
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 0 + "'", int34 == 0);
}
@Test
@Ignore
public void test1778() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1778");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
org.joda.time.ReadableInstant readableInstant17 = null;
mutableDateTime11.setDate(readableInstant17);
java.util.Date date19 = mutableDateTime11.toDate();
mutableDateTime11.setWeekyear(10);
mutableDateTime11.add((long) 70);
mutableDateTime2.setDate((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime2.centuryOfEra();
java.lang.String str26 = property25.getAsShortText();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:11.584Z" + "'", str13, "2020-11-25T01:49:11.584Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(date19);
// flaky: org.junit.Assert.assertEquals(date19.toString(), "Wed Nov 25 01:49:11 UTC 2020");
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertEquals("'" + str26 + "' != '" + "0" + "'", str26, "0");
}
@Test
@Ignore
public void test1779() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1779");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
java.util.GregorianCalendar gregorianCalendar15 = mutableDateTime13.toGregorianCalendar();
mutableDateTime13.addDays(6531907);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.616Z" + "'", str4, "2020-11-25T01:49:11.616Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
org.junit.Assert.assertNotNull(gregorianCalendar15);
}
@Test
@Ignore
public void test1780() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1780");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.DateTimeZone dateTimeZone8 = mutableDateTime7.getZone();
mutableDateTime7.setMinuteOfDay(4);
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
int int16 = mutableDateTime13.getYearOfCentury();
org.joda.time.Chronology chronology17 = mutableDateTime13.getChronology();
int int18 = mutableDateTime13.getWeekOfWeekyear();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.DateTimeZone dateTimeZone22 = mutableDateTime21.getZone();
org.joda.time.DateTime dateTime23 = mutableDateTime13.toDateTime(dateTimeZone22);
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime7.toMutableDateTime(dateTimeZone22);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone22);
org.joda.time.MutableDateTime mutableDateTime26 = mutableDateTime2.toMutableDateTime(dateTimeZone22);
mutableDateTime2.setMinuteOfDay(9);
boolean boolean29 = mutableDateTime2.isAfterNow();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
org.joda.time.ReadablePeriod readablePeriod35 = null;
mutableDateTime32.add(readablePeriod35);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime32.hourOfDay();
org.joda.time.MutableDateTime.Property property38 = mutableDateTime32.dayOfWeek();
org.joda.time.MutableDateTime.Property property39 = mutableDateTime32.secondOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType40 = property39.getFieldType();
org.joda.time.MutableDateTime.Property property41 = mutableDateTime2.property(dateTimeFieldType40);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(dateTimeZone8);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:11.742Z" + "'", str15, "2020-11-25T01:49:11.742Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 20 + "'", int16 == 20);
org.junit.Assert.assertNotNull(chronology17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 48 + "'", int18 == 48);
org.junit.Assert.assertNotNull(dateTimeZone22);
org.junit.Assert.assertNotNull(dateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + false + "'", boolean29 == false);
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:11.742Z" + "'", str34, "2020-11-25T01:49:11.742Z");
org.junit.Assert.assertNotNull(property37);
org.junit.Assert.assertNotNull(property38);
org.junit.Assert.assertNotNull(property39);
org.junit.Assert.assertNotNull(dateTimeFieldType40);
org.junit.Assert.assertNotNull(property41);
}
@Test
@Ignore
public void test1781() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1781");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property15.addWrapField((int) '4');
org.joda.time.DateTimeField dateTimeField18 = property15.getField();
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundCeiling();
java.util.Locale locale21 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime22 = property15.set("2020-11-25T01:47:23.898Z", locale21);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value \"2020-11-25T01:47:23.898Z\" for secondOfDay is not supported");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:11.810Z" + "'", str4, "2020-11-25T01:49:11.810Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(dateTimeField18);
org.junit.Assert.assertNotNull(mutableDateTime19);
}
@Test
public void test1782() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1782");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) 31);
}
@Test
@Ignore
public void test1783() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1783");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone4);
org.joda.time.DateTime dateTime6 = mutableDateTime5.toDateTimeISO();
java.util.Date date7 = mutableDateTime5.toDate();
mutableDateTime5.addDays(99);
mutableDateTime5.addWeeks(6549032);
org.junit.Assert.assertNotNull(dateTimeZone4);
org.junit.Assert.assertNotNull(dateTime6);
org.junit.Assert.assertNotNull(date7);
org.junit.Assert.assertEquals(date7.toString(), "Wed Nov 25 01:44:41 UTC 2020");
}
@Test
public void test1784() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1784");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfMonth();
boolean boolean4 = mutableDateTime1.isBefore((long) 9);
org.joda.time.Chronology chronology5 = mutableDateTime1.getChronology();
org.joda.time.MutableDateTime mutableDateTime6 = org.joda.time.MutableDateTime.now(chronology5);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(6437123L, chronology5);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
org.junit.Assert.assertNotNull(chronology5);
org.junit.Assert.assertNotNull(mutableDateTime6);
}
@Test
@Ignore
public void test1785() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1785");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
java.lang.Object obj6 = null;
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime(obj6, chronology7);
org.joda.time.format.DateTimeFormatter dateTimeFormatter9 = null;
java.lang.String str10 = mutableDateTime8.toString(dateTimeFormatter9);
org.joda.time.ReadablePeriod readablePeriod11 = null;
mutableDateTime8.add(readablePeriod11);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime8.hourOfDay();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime8.dayOfWeek();
int int15 = property14.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime17 = property14.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime18 = property14.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime18.add(readablePeriod19, 40);
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.format.DateTimeFormatter dateTimeFormatter25 = null;
java.lang.String str26 = mutableDateTime24.toString(dateTimeFormatter25);
int int27 = mutableDateTime24.getYearOfCentury();
org.joda.time.Chronology chronology28 = mutableDateTime24.getChronology();
org.joda.time.MutableDateTime mutableDateTime29 = mutableDateTime18.toMutableDateTime(chronology28);
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime((long) 100, chronology28);
org.joda.time.MutableDateTime mutableDateTime31 = org.joda.time.MutableDateTime.now(chronology28);
org.joda.time.MutableDateTime mutableDateTime32 = mutableDateTime2.toMutableDateTime(chronology28);
org.joda.time.ReadableDuration readableDuration33 = null;
mutableDateTime2.add(readableDuration33);
mutableDateTime2.setMinuteOfHour(35);
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setDayOfYear((int) (short) -1);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value -1 for dayOfYear must be in the range [1,365]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str10 + "' != '" + "2020-11-25T01:49:11.970Z" + "'", str10, "2020-11-25T01:49:11.970Z");
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 7 + "'", int15 == 7);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(mutableDateTime18);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:11.970Z" + "'", str26, "2020-11-25T01:49:11.970Z");
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 20 + "'", int27 == 20);
org.junit.Assert.assertNotNull(chronology28);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime32);
}
@Test
@Ignore
public void test1786() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1786");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.ReadableInstant readableInstant8 = null;
mutableDateTime2.setDate(readableInstant8);
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfMonth();
int int12 = mutableDateTime10.getCenturyOfEra();
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology14);
mutableDateTime15.setSecondOfMinute((int) '4');
int int18 = mutableDateTime15.getMinuteOfDay();
int int19 = mutableDateTime15.getCenturyOfEra();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
int int23 = mutableDateTime22.getDayOfWeek();
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.DateTimeZone dateTimeZone27 = mutableDateTime26.getZone();
org.joda.time.MutableDateTime mutableDateTime28 = org.joda.time.MutableDateTime.now(dateTimeZone27);
mutableDateTime22.setZoneRetainFields(dateTimeZone27);
org.joda.time.DateTime dateTime30 = mutableDateTime15.toDateTime(dateTimeZone27);
mutableDateTime10.setZoneRetainFields(dateTimeZone27);
mutableDateTime2.setZone(dateTimeZone27);
java.lang.Object obj33 = null;
org.joda.time.Chronology chronology34 = null;
org.joda.time.MutableDateTime mutableDateTime35 = new org.joda.time.MutableDateTime(obj33, chronology34);
org.joda.time.format.DateTimeFormatter dateTimeFormatter36 = null;
java.lang.String str37 = mutableDateTime35.toString(dateTimeFormatter36);
org.joda.time.ReadablePeriod readablePeriod38 = null;
mutableDateTime35.add(readablePeriod38);
org.joda.time.MutableDateTime.Property property40 = mutableDateTime35.hourOfDay();
java.lang.String str41 = mutableDateTime35.toString();
boolean boolean42 = mutableDateTime35.isEqualNow();
org.joda.time.MutableDateTime.Property property43 = mutableDateTime35.hourOfDay();
java.lang.Object obj44 = null;
org.joda.time.Chronology chronology45 = null;
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime(obj44, chronology45);
org.joda.time.format.DateTimeFormatter dateTimeFormatter47 = null;
java.lang.String str48 = mutableDateTime46.toString(dateTimeFormatter47);
org.joda.time.ReadablePeriod readablePeriod49 = null;
mutableDateTime46.add(readablePeriod49);
org.joda.time.MutableDateTime.Property property51 = mutableDateTime46.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType52 = property51.getFieldType();
org.joda.time.MutableDateTime.Property property53 = mutableDateTime35.property(dateTimeFieldType52);
int int54 = mutableDateTime2.get(dateTimeFieldType52);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.002Z" + "'", str4, "2020-11-25T01:49:12.002Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 20 + "'", int12 == 20);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 19 + "'", int19 == 19);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 3 + "'", int23 == 3);
org.junit.Assert.assertNotNull(dateTimeZone27);
org.junit.Assert.assertNotNull(mutableDateTime28);
org.junit.Assert.assertNotNull(dateTime30);
// flaky: org.junit.Assert.assertEquals("'" + str37 + "' != '" + "2020-11-25T01:49:12.002Z" + "'", str37, "2020-11-25T01:49:12.002Z");
org.junit.Assert.assertNotNull(property40);
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:12.002Z" + "'", str41, "2020-11-25T01:49:12.002Z");
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + true + "'", boolean42 == true);
org.junit.Assert.assertNotNull(property43);
// flaky: org.junit.Assert.assertEquals("'" + str48 + "' != '" + "2020-11-25T01:49:12.002Z" + "'", str48, "2020-11-25T01:49:12.002Z");
org.junit.Assert.assertNotNull(property51);
org.junit.Assert.assertNotNull(dateTimeFieldType52);
org.junit.Assert.assertNotNull(property53);
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 1 + "'", int54 == 1);
}
@Test
@Ignore
public void test1787() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1787");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
java.util.Locale locale7 = null;
java.lang.String str8 = property6.getAsText(locale7);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
int int12 = mutableDateTime11.getDayOfWeek();
mutableDateTime11.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime11.secondOfMinute();
org.joda.time.DateTimeZone dateTimeZone16 = mutableDateTime11.getZone();
int int17 = mutableDateTime11.getYearOfCentury();
int int18 = property6.getDifference((org.joda.time.ReadableInstant) mutableDateTime11);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "12" + "'", str8, "12");
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 3 + "'", int12 == 3);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(dateTimeZone16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 20 + "'", int17 == 20);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
}
@Test
@Ignore
public void test1788() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1788");
java.lang.Object obj2 = null;
org.joda.time.Chronology chronology3 = null;
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime(obj2, chronology3);
org.joda.time.DateTimeZone dateTimeZone5 = mutableDateTime4.getZone();
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone5);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone5);
int int8 = mutableDateTime7.getDayOfWeek();
org.joda.time.format.DateTimeFormatter dateTimeFormatter9 = null;
java.lang.String str10 = mutableDateTime7.toString(dateTimeFormatter9);
org.junit.Assert.assertNotNull(dateTimeZone5);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 4 + "'", int8 == 4);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "1970-01-01T00:00:00.627Z" + "'", str10, "1970-01-01T00:00:00.627Z");
}
@Test
public void test1789() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1789");
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(6353, 286086, 271, 687, 1439, 6439, 6464264);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 687 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
}
@Test
public void test1790() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1790");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
java.lang.String str8 = mutableDateTime2.toString();
boolean boolean9 = mutableDateTime2.isEqualNow();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime2.hourOfDay();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
org.joda.time.ReadablePeriod readablePeriod16 = null;
mutableDateTime13.add(readablePeriod16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType19 = property18.getFieldType();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime2.property(dateTimeFieldType19);
long long21 = mutableDateTime2.getMillis();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime2.weekOfWeekyear();
org.joda.time.MutableDateTime mutableDateTime23 = property22.roundHalfFloor();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.155Z" + "'", str4, "2020-11-25T01:49:12.155Z");
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T01:49:12.155Z" + "'", str8, "2020-11-25T01:49:12.155Z");
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + true + "'", boolean9 == true);
org.junit.Assert.assertNotNull(property10);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:12.155Z" + "'", str15, "2020-11-25T01:49:12.155Z");
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeFieldType19);
org.junit.Assert.assertNotNull(property20);
// flaky: org.junit.Assert.assertTrue("'" + long21 + "' != '" + 1606268952155L + "'", long21 == 1606268952155L);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertNotNull(mutableDateTime23);
}
@Test
@Ignore
public void test1791() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1791");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime2.add(readablePeriod7);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
mutableDateTime11.setTime((long) '#');
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime18.add(readablePeriod21);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime18.hourOfDay();
java.lang.String str24 = mutableDateTime18.toString();
int int25 = mutableDateTime11.compareTo((org.joda.time.ReadableInstant) mutableDateTime18);
java.lang.Object obj26 = mutableDateTime11.clone();
long long27 = mutableDateTime11.getMillis();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType36 = property35.getFieldType();
int int37 = mutableDateTime11.get(dateTimeFieldType36);
org.joda.time.MutableDateTime.Property property38 = mutableDateTime2.property(dateTimeFieldType36);
mutableDateTime2.setDayOfYear((int) (short) 100);
java.lang.Object obj41 = null;
org.joda.time.Chronology chronology42 = null;
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime(obj41, chronology42);
org.joda.time.format.DateTimeFormatter dateTimeFormatter44 = null;
java.lang.String str45 = mutableDateTime43.toString(dateTimeFormatter44);
org.joda.time.ReadablePeriod readablePeriod46 = null;
mutableDateTime43.add(readablePeriod46);
org.joda.time.MutableDateTime.Property property48 = mutableDateTime43.hourOfDay();
org.joda.time.MutableDateTime.Property property49 = mutableDateTime43.dayOfWeek();
int int50 = property49.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime52 = property49.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime53 = property49.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod54 = null;
mutableDateTime53.add(readablePeriod54, 40);
java.lang.Object obj57 = null;
org.joda.time.Chronology chronology58 = null;
org.joda.time.MutableDateTime mutableDateTime59 = new org.joda.time.MutableDateTime(obj57, chronology58);
org.joda.time.format.DateTimeFormatter dateTimeFormatter60 = null;
java.lang.String str61 = mutableDateTime59.toString(dateTimeFormatter60);
int int62 = mutableDateTime59.getYearOfCentury();
org.joda.time.Chronology chronology63 = mutableDateTime59.getChronology();
org.joda.time.MutableDateTime mutableDateTime64 = mutableDateTime53.toMutableDateTime(chronology63);
org.joda.time.MutableDateTime mutableDateTime65 = org.joda.time.MutableDateTime.now(chronology63);
java.lang.Object obj66 = null;
org.joda.time.Chronology chronology67 = null;
org.joda.time.MutableDateTime mutableDateTime68 = new org.joda.time.MutableDateTime(obj66, chronology67);
org.joda.time.format.DateTimeFormatter dateTimeFormatter69 = null;
java.lang.String str70 = mutableDateTime68.toString(dateTimeFormatter69);
org.joda.time.ReadablePeriod readablePeriod71 = null;
mutableDateTime68.add(readablePeriod71);
org.joda.time.MutableDateTime.Property property73 = mutableDateTime68.hourOfDay();
org.joda.time.MutableDateTime.Property property74 = mutableDateTime68.dayOfWeek();
org.joda.time.DurationField durationField75 = property74.getRangeDurationField();
org.joda.time.DurationField durationField76 = property74.getDurationField();
org.joda.time.DateTimeField dateTimeField77 = property74.getField();
mutableDateTime65.setRounding(dateTimeField77);
org.joda.time.DateTimeZone dateTimeZone79 = mutableDateTime65.getZone();
org.joda.time.MutableDateTime mutableDateTime80 = org.joda.time.MutableDateTime.now(dateTimeZone79);
org.joda.time.MutableDateTime mutableDateTime81 = mutableDateTime2.toMutableDateTime(dateTimeZone79);
org.joda.time.MutableDateTime.Property property82 = mutableDateTime81.yearOfCentury();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str4, "2020-11-25T01:49:12.191Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str13, "2020-11-25T01:49:12.191Z");
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str20, "2020-11-25T01:49:12.191Z");
org.junit.Assert.assertNotNull(property23);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str24, "2020-11-25T01:49:12.191Z");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + (-1) + "'", int25 == (-1));
org.junit.Assert.assertNotNull(obj26);
org.junit.Assert.assertEquals(obj26.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj26), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj26), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long27 + "' != '" + 1606262400035L + "'", long27 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str32, "2020-11-25T01:49:12.191Z");
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(dateTimeFieldType36);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 0 + "'", int37 == 0);
org.junit.Assert.assertNotNull(property38);
// flaky: org.junit.Assert.assertEquals("'" + str45 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str45, "2020-11-25T01:49:12.191Z");
org.junit.Assert.assertNotNull(property48);
org.junit.Assert.assertNotNull(property49);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 7 + "'", int50 == 7);
org.junit.Assert.assertNotNull(mutableDateTime52);
org.junit.Assert.assertNotNull(mutableDateTime53);
// flaky: org.junit.Assert.assertEquals("'" + str61 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str61, "2020-11-25T01:49:12.191Z");
org.junit.Assert.assertTrue("'" + int62 + "' != '" + 20 + "'", int62 == 20);
org.junit.Assert.assertNotNull(chronology63);
org.junit.Assert.assertNotNull(mutableDateTime64);
org.junit.Assert.assertNotNull(mutableDateTime65);
// flaky: org.junit.Assert.assertEquals("'" + str70 + "' != '" + "2020-11-25T01:49:12.191Z" + "'", str70, "2020-11-25T01:49:12.191Z");
org.junit.Assert.assertNotNull(property73);
org.junit.Assert.assertNotNull(property74);
org.junit.Assert.assertNotNull(durationField75);
org.junit.Assert.assertNotNull(durationField76);
org.junit.Assert.assertNotNull(dateTimeField77);
org.junit.Assert.assertNotNull(dateTimeZone79);
org.junit.Assert.assertNotNull(mutableDateTime80);
org.junit.Assert.assertNotNull(mutableDateTime81);
org.junit.Assert.assertNotNull(property82);
}
@Test
@Ignore
public void test1792() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1792");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime6.dayOfWeek();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
mutableDateTime10.addSeconds((int) (byte) 0);
int int14 = mutableDateTime10.getSecondOfMinute();
mutableDateTime10.setWeekyear(20);
mutableDateTime6.setMillis((org.joda.time.ReadableInstant) mutableDateTime10);
mutableDateTime10.addMonths(47);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int14 + "' != '" + 12 + "'", int14 == 12);
}
@Test
public void test1793() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1793");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DateTimeField dateTimeField9 = mutableDateTime2.getRoundingField();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.centuryOfEra();
org.joda.time.ReadableInstant readableInstant18 = null;
mutableDateTime12.setDate(readableInstant18);
mutableDateTime12.setMillis((long) 'a');
boolean boolean22 = mutableDateTime2.isAfter((org.joda.time.ReadableInstant) mutableDateTime12);
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setMinuteOfHour(56942393);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 56942393 for minuteOfHour must be in the range [0,59]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.365Z" + "'", str4, "2020-11-25T01:49:12.365Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNull(dateTimeField9);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:12.365Z" + "'", str14, "2020-11-25T01:49:12.365Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + true + "'", boolean22 == true);
}
@Test
@Ignore
public void test1794() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1794");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
org.joda.time.MutableDateTime mutableDateTime33 = property2.roundFloor();
java.util.Locale locale34 = null;
java.lang.String str35 = property2.getAsText(locale34);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:12.414Z" + "'", str13, "2020-11-25T01:49:12.414Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:12.415Z" + "'", str27, "2020-11-25T01:49:12.415Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertEquals("'" + str35 + "' != '" + "1970" + "'", str35, "1970");
}
@Test
public void test1795() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1795");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((-50L));
java.lang.Object obj2 = null;
org.joda.time.Chronology chronology3 = null;
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime(obj2, chronology3);
org.joda.time.format.DateTimeFormatter dateTimeFormatter5 = null;
java.lang.String str6 = mutableDateTime4.toString(dateTimeFormatter5);
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime4.add(readablePeriod7);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime4.yearOfCentury();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime4.dayOfWeek();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime4.millisOfDay();
mutableDateTime4.add((long) 3);
mutableDateTime4.addWeekyears((int) (byte) 100);
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology17);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime18.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime18.copy();
mutableDateTime4.setDate((org.joda.time.ReadableInstant) mutableDateTime18);
org.joda.time.MutableDateTime.Property property22 = mutableDateTime4.weekOfWeekyear();
mutableDateTime4.addMinutes(21);
mutableDateTime1.setTime((org.joda.time.ReadableInstant) mutableDateTime4);
// flaky: org.junit.Assert.assertEquals("'" + str6 + "' != '" + "2020-11-25T01:49:12.454Z" + "'", str6, "2020-11-25T01:49:12.454Z");
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertNotNull(property22);
}
@Test
public void test1796() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1796");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
org.joda.time.DateTimeField dateTimeField19 = property18.getField();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
mutableDateTime21.add((long) 376);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.486Z" + "'", str4, "2020-11-25T01:49:12.486Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:12.486Z" + "'", str11, "2020-11-25T01:49:12.486Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:12.486Z" + "'", str15, "2020-11-25T01:49:12.486Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeField19);
org.junit.Assert.assertNotNull(mutableDateTime21);
}
@Test
@Ignore
public void test1797() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1797");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
int int17 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.MutableDateTime mutableDateTime18 = mutableDateTime11.toMutableDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime11.toMutableDateTimeISO();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
int int25 = mutableDateTime22.getYearOfCentury();
org.joda.time.Chronology chronology26 = mutableDateTime22.getChronology();
mutableDateTime19.setChronology(chronology26);
org.joda.time.MutableDateTime mutableDateTime28 = mutableDateTime19.toMutableDateTime();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.519Z" + "'", str4, "2020-11-25T01:49:12.519Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:12.520Z" + "'", str13, "2020-11-25T01:49:12.520Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 0 + "'", int17 == 0);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:12.520Z" + "'", str24, "2020-11-25T01:49:12.520Z");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 20 + "'", int25 == 20);
org.junit.Assert.assertNotNull(chronology26);
org.junit.Assert.assertNotNull(mutableDateTime28);
}
@Test
public void test1798() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1798");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
int int3 = property2.getMinimumValue();
org.joda.time.MutableDateTime mutableDateTime4 = property2.roundCeiling();
org.joda.time.Interval interval5 = property2.toInterval();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + (-292275054) + "'", int3 == (-292275054));
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(interval5);
}
@Test
@Ignore
public void test1799() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1799");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
int int10 = mutableDateTime2.getWeekOfWeekyear();
mutableDateTime2.add(0L);
int int13 = mutableDateTime2.getMillisOfSecond();
int int14 = mutableDateTime2.getDayOfYear();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.millisOfSecond();
org.joda.time.DurationField durationField16 = property15.getRangeDurationField();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.610Z" + "'", str4, "2020-11-25T01:49:12.610Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 48 + "'", int10 == 48);
// flaky: org.junit.Assert.assertTrue("'" + int13 + "' != '" + 610 + "'", int13 == 610);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 330 + "'", int14 == 330);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(durationField16);
}
@Test
public void test1800() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1800");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.minuteOfHour();
int int14 = mutableDateTime12.getSecondOfMinute();
// The following exception was thrown during execution in test generation
try {
mutableDateTime12.setMonthOfYear(6281);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6281 for monthOfYear must be in the range [1,12]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.645Z" + "'", str4, "2020-11-25T01:49:12.645Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
}
@Test
public void test1801() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1801");
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime((int) (byte) 10, 23, 53, 1, 6464264, 335, (int) (byte) 10);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6464264 for minuteOfHour must be in the range [0,59]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1802() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1802");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
org.joda.time.DurationField durationField10 = property8.getDurationField();
java.lang.String str11 = property8.getAsShortText();
long long12 = property8.remainder();
org.joda.time.DurationField durationField13 = property8.getLeapDurationField();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.hourOfDay();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime16.dayOfWeek();
int int23 = property22.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime24 = property22.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfYear();
mutableDateTime24.setMillis((long) 2400000);
long long28 = property8.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime24);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.697Z" + "'", str4, "2020-11-25T01:49:12.697Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Wed" + "'", str11, "Wed");
// flaky: org.junit.Assert.assertTrue("'" + long12 + "' != '" + 6552697L + "'", long12 == 6552697L);
org.junit.Assert.assertNull(durationField13);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:12.697Z" + "'", str18, "2020-11-25T01:49:12.697Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 7 + "'", int23 == 7);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + long28 + "' != '" + 18591L + "'", long28 == 18591L);
}
@Test
@Ignore
public void test1803() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1803");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.DateTime dateTime2 = mutableDateTime1.toDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property5 = mutableDateTime4.weekyear();
long long6 = property5.remainder();
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology8);
mutableDateTime9.setSecondOfMinute((int) '4');
int int12 = mutableDateTime9.getMinuteOfDay();
int int13 = mutableDateTime9.getCenturyOfEra();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
int int17 = mutableDateTime16.getDayOfWeek();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.DateTimeZone dateTimeZone21 = mutableDateTime20.getZone();
org.joda.time.MutableDateTime mutableDateTime22 = org.joda.time.MutableDateTime.now(dateTimeZone21);
mutableDateTime16.setZoneRetainFields(dateTimeZone21);
org.joda.time.DateTime dateTime24 = mutableDateTime9.toDateTime(dateTimeZone21);
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(dateTimeZone21);
long long26 = property5.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime25);
org.joda.time.MutableDateTime mutableDateTime27 = property5.getMutableDateTime();
org.joda.time.MutableDateTime mutableDateTime29 = property5.add((long) 9);
org.joda.time.MutableDateTime.Property property30 = mutableDateTime29.secondOfMinute();
org.joda.time.DateTimeZone dateTimeZone32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((long) 100, dateTimeZone32);
boolean boolean34 = mutableDateTime29.isAfter((org.joda.time.ReadableInstant) mutableDateTime33);
boolean boolean36 = mutableDateTime33.isBefore((long) 48);
mutableDateTime1.setDate((org.joda.time.ReadableInstant) mutableDateTime33);
// The following exception was thrown during execution in test generation
try {
mutableDateTime33.setTime(2060, 6538011, 112, 21);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 2060 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(dateTime2);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertTrue("'" + long6 + "' != '" + 259200010L + "'", long6 == 259200010L);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 19 + "'", int13 == 19);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 3 + "'", int17 == 3);
org.junit.Assert.assertNotNull(dateTimeZone21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(dateTime24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertTrue("'" + long26 + "' != '" + (-50L) + "'", long26 == (-50L));
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(property30);
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + true + "'", boolean34 == true);
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + false + "'", boolean36 == false);
}
@Test
public void test1804() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1804");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
mutableDateTime20.setTime((long) '#');
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.format.DateTimeFormatter dateTimeFormatter28 = null;
java.lang.String str29 = mutableDateTime27.toString(dateTimeFormatter28);
org.joda.time.ReadablePeriod readablePeriod30 = null;
mutableDateTime27.add(readablePeriod30);
org.joda.time.MutableDateTime.Property property32 = mutableDateTime27.hourOfDay();
java.lang.String str33 = mutableDateTime27.toString();
int int34 = mutableDateTime20.compareTo((org.joda.time.ReadableInstant) mutableDateTime27);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime27.millisOfDay();
org.joda.time.Chronology chronology36 = mutableDateTime27.getChronology();
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology36);
org.joda.time.MutableDateTime mutableDateTime38 = org.joda.time.MutableDateTime.now(chronology36);
org.joda.time.MutableDateTime.Property property39 = mutableDateTime38.minuteOfHour();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.770Z" + "'", str4, "2020-11-25T01:49:12.770Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:12.770Z" + "'", str11, "2020-11-25T01:49:12.770Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:12.770Z" + "'", str15, "2020-11-25T01:49:12.770Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:12.770Z" + "'", str22, "2020-11-25T01:49:12.770Z");
// flaky: org.junit.Assert.assertEquals("'" + str29 + "' != '" + "2020-11-25T01:49:12.770Z" + "'", str29, "2020-11-25T01:49:12.770Z");
org.junit.Assert.assertNotNull(property32);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:49:12.770Z" + "'", str33, "2020-11-25T01:49:12.770Z");
org.junit.Assert.assertTrue("'" + int34 + "' != '" + (-1) + "'", int34 == (-1));
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(chronology36);
org.junit.Assert.assertNotNull(mutableDateTime38);
org.junit.Assert.assertNotNull(property39);
}
@Test
@Ignore
public void test1805() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1805");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
int int6 = mutableDateTime3.getYearOfCentury();
org.joda.time.Chronology chronology7 = mutableDateTime3.getChronology();
int int8 = mutableDateTime3.getWeekOfWeekyear();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.DateTimeZone dateTimeZone12 = mutableDateTime11.getZone();
org.joda.time.DateTime dateTime13 = mutableDateTime3.toDateTime(dateTimeZone12);
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((-1L), dateTimeZone12);
org.joda.time.MutableDateTime mutableDateTime15 = mutableDateTime14.toMutableDateTimeISO();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime15.minuteOfDay();
org.joda.time.MutableDateTime.Property property17 = mutableDateTime15.secondOfMinute();
org.joda.time.MutableDateTime mutableDateTime18 = property17.roundCeiling();
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:12.817Z" + "'", str5, "2020-11-25T01:49:12.817Z");
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 20 + "'", int6 == 20);
org.junit.Assert.assertNotNull(chronology7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 48 + "'", int8 == 48);
org.junit.Assert.assertNotNull(dateTimeZone12);
org.junit.Assert.assertNotNull(dateTime13);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(mutableDateTime18);
}
@Test
@Ignore
public void test1806() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1806");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime13 = property8.roundHalfFloor();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
int int17 = mutableDateTime16.getDayOfWeek();
mutableDateTime16.addSeconds((int) (byte) 0);
int int20 = mutableDateTime16.getSecondOfMinute();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
mutableDateTime23.setTime((long) '#');
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
java.lang.String str36 = mutableDateTime30.toString();
int int37 = mutableDateTime23.compareTo((org.joda.time.ReadableInstant) mutableDateTime30);
java.lang.Object obj38 = mutableDateTime23.clone();
long long39 = mutableDateTime23.getMillis();
java.lang.Object obj40 = null;
org.joda.time.Chronology chronology41 = null;
org.joda.time.MutableDateTime mutableDateTime42 = new org.joda.time.MutableDateTime(obj40, chronology41);
org.joda.time.format.DateTimeFormatter dateTimeFormatter43 = null;
java.lang.String str44 = mutableDateTime42.toString(dateTimeFormatter43);
org.joda.time.ReadablePeriod readablePeriod45 = null;
mutableDateTime42.add(readablePeriod45);
org.joda.time.MutableDateTime.Property property47 = mutableDateTime42.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType48 = property47.getFieldType();
int int49 = mutableDateTime23.get(dateTimeFieldType48);
int int50 = mutableDateTime16.get(dateTimeFieldType48);
int int51 = mutableDateTime16.getSecondOfDay();
int int52 = mutableDateTime16.getMonthOfYear();
int int53 = mutableDateTime16.getSecondOfDay();
mutableDateTime13.setMillis((org.joda.time.ReadableInstant) mutableDateTime16);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:12.858Z" + "'", str4, "2020-11-25T01:49:12.858Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 3 + "'", int17 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int20 + "' != '" + 12 + "'", int20 == 12);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:12.858Z" + "'", str25, "2020-11-25T01:49:12.858Z");
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:12.858Z" + "'", str32, "2020-11-25T01:49:12.858Z");
org.junit.Assert.assertNotNull(property35);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:12.858Z" + "'", str36, "2020-11-25T01:49:12.858Z");
org.junit.Assert.assertTrue("'" + int37 + "' != '" + (-1) + "'", int37 == (-1));
org.junit.Assert.assertNotNull(obj38);
org.junit.Assert.assertEquals(obj38.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj38), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj38), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long39 + "' != '" + 1606262400035L + "'", long39 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str44 + "' != '" + "2020-11-25T01:49:12.858Z" + "'", str44, "2020-11-25T01:49:12.858Z");
org.junit.Assert.assertNotNull(property47);
org.junit.Assert.assertNotNull(dateTimeFieldType48);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 0 + "'", int49 == 0);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 1 + "'", int50 == 1);
// flaky: org.junit.Assert.assertTrue("'" + int51 + "' != '" + 6552 + "'", int51 == 6552);
org.junit.Assert.assertTrue("'" + int52 + "' != '" + 11 + "'", int52 == 11);
// flaky: org.junit.Assert.assertTrue("'" + int53 + "' != '" + 6552 + "'", int53 == 6552);
}
@Test
public void test1807() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1807");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
int int17 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime11);
boolean boolean19 = mutableDateTime11.equals((java.lang.Object) "2020-11-25T01:45:49.189Z");
mutableDateTime11.addDays(6541);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:13.033Z" + "'", str4, "2020-11-25T01:49:13.033Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:13.033Z" + "'", str13, "2020-11-25T01:49:13.033Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 0 + "'", int17 == 0);
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + false + "'", boolean19 == false);
}
@Test
public void test1808() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1808");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property3.add((long) (short) -1);
org.joda.time.Interval interval6 = property3.toInterval();
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime8 = property3.add(1606268691967L);
org.junit.Assert.fail("Expected exception of type java.lang.ArithmeticException; message: Multiplication overflows a long: 1606268691967 * 86400000");
} catch (java.lang.ArithmeticException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(interval6);
}
@Test
@Ignore
public void test1809() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1809");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
org.joda.time.ReadableDuration readableDuration16 = null;
mutableDateTime12.add(readableDuration16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime12.secondOfDay();
java.lang.String str19 = mutableDateTime12.toString();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:13.093Z" + "'", str4, "2020-11-25T01:49:13.093Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertEquals("'" + str19 + "' != '" + "2020-11-25T00:00:00.000Z" + "'", str19, "2020-11-25T00:00:00.000Z");
}
@Test
@Ignore
public void test1810() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1810");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
int int6 = mutableDateTime2.getMonthOfYear();
int int7 = mutableDateTime2.getHourOfDay();
mutableDateTime2.addSeconds(6382);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime2.millisOfSecond();
int int11 = mutableDateTime2.getDayOfMonth();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 11 + "'", int6 == 11);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 25 + "'", int11 == 25);
}
@Test
@Ignore
public void test1811() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1811");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.year();
java.lang.String str15 = mutableDateTime12.toString("330");
org.joda.time.MutableDateTime.Property property16 = mutableDateTime12.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime17 = property16.roundHalfFloor();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
org.joda.time.ReadablePeriod readablePeriod23 = null;
mutableDateTime20.add(readablePeriod23);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime20.hourOfDay();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime20.dayOfWeek();
int int27 = property26.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime29 = property26.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime30 = property26.roundHalfEven();
org.joda.time.MutableDateTime.Property property31 = mutableDateTime30.year();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.format.DateTimeFormatter dateTimeFormatter35 = null;
java.lang.String str36 = mutableDateTime34.toString(dateTimeFormatter35);
int int37 = mutableDateTime34.getYearOfCentury();
org.joda.time.Chronology chronology38 = mutableDateTime34.getChronology();
int int39 = mutableDateTime34.getWeekOfWeekyear();
java.lang.Object obj40 = null;
org.joda.time.Chronology chronology41 = null;
org.joda.time.MutableDateTime mutableDateTime42 = new org.joda.time.MutableDateTime(obj40, chronology41);
org.joda.time.DateTimeZone dateTimeZone43 = mutableDateTime42.getZone();
org.joda.time.DateTime dateTime44 = mutableDateTime34.toDateTime(dateTimeZone43);
org.joda.time.MutableDateTime mutableDateTime45 = mutableDateTime34.copy();
org.joda.time.MutableDateTime.Property property46 = mutableDateTime45.dayOfWeek();
mutableDateTime30.setDate((org.joda.time.ReadableInstant) mutableDateTime45);
org.joda.time.Instant instant48 = mutableDateTime45.toInstant();
mutableDateTime17.setDate((org.joda.time.ReadableInstant) instant48);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:13.157Z" + "'", str4, "2020-11-25T01:49:13.157Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "330" + "'", str15, "330");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:13.157Z" + "'", str22, "2020-11-25T01:49:13.157Z");
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 7 + "'", int27 == 7);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(property31);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:13.157Z" + "'", str36, "2020-11-25T01:49:13.157Z");
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 20 + "'", int37 == 20);
org.junit.Assert.assertNotNull(chronology38);
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 48 + "'", int39 == 48);
org.junit.Assert.assertNotNull(dateTimeZone43);
org.junit.Assert.assertNotNull(dateTime44);
org.junit.Assert.assertNotNull(mutableDateTime45);
org.junit.Assert.assertNotNull(property46);
org.junit.Assert.assertNotNull(instant48);
}
@Test
@Ignore
public void test1812() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1812");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.weekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
int int13 = mutableDateTime10.getYearOfCentury();
org.joda.time.Chronology chronology14 = mutableDateTime10.getChronology();
int int15 = mutableDateTime10.getWeekOfWeekyear();
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.DateTimeZone dateTimeZone19 = mutableDateTime18.getZone();
org.joda.time.DateTime dateTime20 = mutableDateTime10.toDateTime(dateTimeZone19);
org.joda.time.MutableDateTime mutableDateTime21 = mutableDateTime10.copy();
boolean boolean22 = mutableDateTime10.isAfterNow();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime10.centuryOfEra();
int int24 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime10);
mutableDateTime10.setSecondOfDay(21);
mutableDateTime10.addHours(104);
org.joda.time.MutableDateTime.Property property29 = mutableDateTime10.secondOfDay();
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime31 = property29.set("2020-11-25T01:49:10.819Z");
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value \"2020-11-25T01:49:10.819Z\" for secondOfDay is not supported");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:13.216Z" + "'", str12, "2020-11-25T01:49:13.216Z");
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 20 + "'", int13 == 20);
org.junit.Assert.assertNotNull(chronology14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 48 + "'", int15 == 48);
org.junit.Assert.assertNotNull(dateTimeZone19);
org.junit.Assert.assertNotNull(dateTime20);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 0 + "'", int24 == 0);
org.junit.Assert.assertNotNull(property29);
}
@Test
@Ignore
public void test1813() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1813");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.setTime((long) 10);
int int6 = mutableDateTime2.getYearOfCentury();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 20 + "'", int6 == 20);
}
@Test
public void test1814() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1814");
java.lang.Object obj2 = null;
org.joda.time.Chronology chronology3 = null;
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime(obj2, chronology3);
org.joda.time.DateTimeZone dateTimeZone5 = mutableDateTime4.getZone();
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone5);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone5);
mutableDateTime7.setSecondOfMinute((int) (short) 0);
org.joda.time.ReadableDuration readableDuration10 = null;
mutableDateTime7.add(readableDuration10);
mutableDateTime7.setYear(6485);
org.junit.Assert.assertNotNull(dateTimeZone5);
}
@Test
public void test1815() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1815");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.DateTime dateTime2 = mutableDateTime1.toDateTimeISO();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.Instant instant6 = mutableDateTime5.toInstant();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime8.toMutableDateTime();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime8.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime12 = property10.set(49);
org.joda.time.MutableDateTime mutableDateTime13 = property10.roundHalfFloor();
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime16.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime18 = property17.roundCeiling();
mutableDateTime18.setHourOfDay((int) (byte) 0);
mutableDateTime18.setMinuteOfHour(10);
boolean boolean23 = mutableDateTime13.isEqual((org.joda.time.ReadableInstant) mutableDateTime18);
int int24 = mutableDateTime1.compareTo((org.joda.time.ReadableInstant) mutableDateTime13);
org.junit.Assert.assertNotNull(dateTime2);
org.junit.Assert.assertNotNull(instant6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + (-1) + "'", int24 == (-1));
}
@Test
@Ignore
public void test1816() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1816");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
mutableDateTime2.setDate((long) 6300);
boolean boolean9 = mutableDateTime2.isBefore((long) (byte) 0);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime2.add(readablePeriod10, (int) (short) 0);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.centuryOfEra();
org.joda.time.DateTimeField dateTimeField22 = property21.getField();
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
org.joda.time.ReadablePeriod readablePeriod28 = null;
mutableDateTime25.add(readablePeriod28);
org.joda.time.MutableDateTime.Property property30 = mutableDateTime25.centuryOfEra();
int int31 = property21.getDifference((org.joda.time.ReadableInstant) mutableDateTime25);
org.joda.time.MutableDateTime mutableDateTime32 = mutableDateTime25.toMutableDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime33 = mutableDateTime25.toMutableDateTimeISO();
int int34 = mutableDateTime25.getCenturyOfEra();
int int35 = mutableDateTime25.getMonthOfYear();
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
int int41 = mutableDateTime38.getYearOfCentury();
org.joda.time.Chronology chronology42 = mutableDateTime38.getChronology();
org.joda.time.MutableDateTime mutableDateTime43 = org.joda.time.MutableDateTime.now(chronology42);
org.joda.time.Chronology chronology45 = null;
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology45);
org.joda.time.MutableDateTime.Property property47 = mutableDateTime46.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime49 = property47.add((long) (short) -1);
mutableDateTime49.setWeekOfWeekyear((int) '4');
mutableDateTime43.setTime((org.joda.time.ReadableInstant) mutableDateTime49);
org.joda.time.MutableDateTime.Property property53 = mutableDateTime49.secondOfDay();
org.joda.time.MutableDateTime.Property property54 = mutableDateTime49.secondOfMinute();
java.lang.Object obj55 = null;
org.joda.time.Chronology chronology56 = null;
org.joda.time.MutableDateTime mutableDateTime57 = new org.joda.time.MutableDateTime(obj55, chronology56);
org.joda.time.format.DateTimeFormatter dateTimeFormatter58 = null;
java.lang.String str59 = mutableDateTime57.toString(dateTimeFormatter58);
org.joda.time.ReadablePeriod readablePeriod60 = null;
mutableDateTime57.add(readablePeriod60);
org.joda.time.MutableDateTime.Property property62 = mutableDateTime57.yearOfCentury();
org.joda.time.MutableDateTime.Property property63 = mutableDateTime57.dayOfWeek();
org.joda.time.DateTimeFieldType dateTimeFieldType64 = property63.getFieldType();
int int65 = mutableDateTime49.get(dateTimeFieldType64);
org.joda.time.MutableDateTime.Property property66 = mutableDateTime25.property(dateTimeFieldType64);
boolean boolean67 = mutableDateTime13.isSupported(dateTimeFieldType64);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:13.514Z" + "'", str18, "2020-11-25T01:49:13.514Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(dateTimeField22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:13.514Z" + "'", str27, "2020-11-25T01:49:13.514Z");
org.junit.Assert.assertNotNull(property30);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 0 + "'", int31 == 0);
org.junit.Assert.assertNotNull(mutableDateTime32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 20 + "'", int34 == 20);
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 11 + "'", int35 == 11);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:13.514Z" + "'", str40, "2020-11-25T01:49:13.514Z");
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 20 + "'", int41 == 20);
org.junit.Assert.assertNotNull(chronology42);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(property47);
org.junit.Assert.assertNotNull(mutableDateTime49);
org.junit.Assert.assertNotNull(property53);
org.junit.Assert.assertNotNull(property54);
// flaky: org.junit.Assert.assertEquals("'" + str59 + "' != '" + "2020-11-25T01:49:13.514Z" + "'", str59, "2020-11-25T01:49:13.514Z");
org.junit.Assert.assertNotNull(property62);
org.junit.Assert.assertNotNull(property63);
org.junit.Assert.assertNotNull(dateTimeFieldType64);
org.junit.Assert.assertTrue("'" + int65 + "' != '" + 3 + "'", int65 == 3);
org.junit.Assert.assertNotNull(property66);
org.junit.Assert.assertTrue("'" + boolean67 + "' != '" + true + "'", boolean67 == true);
}
@Test
@Ignore
public void test1817() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1817");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property6 = mutableDateTime3.minuteOfDay();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime3.year();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime10.dayOfWeek();
int int17 = property16.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime19 = property16.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime20 = property16.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime20.add(readablePeriod21, 40);
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.format.DateTimeFormatter dateTimeFormatter27 = null;
java.lang.String str28 = mutableDateTime26.toString(dateTimeFormatter27);
int int29 = mutableDateTime26.getYearOfCentury();
org.joda.time.Chronology chronology30 = mutableDateTime26.getChronology();
org.joda.time.MutableDateTime mutableDateTime31 = mutableDateTime20.toMutableDateTime(chronology30);
mutableDateTime3.setChronology(chronology30);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(chronology30);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj0, chronology30);
mutableDateTime34.setTime((long) 4);
org.joda.time.ReadableDuration readableDuration37 = null;
mutableDateTime34.add(readableDuration37);
int int39 = mutableDateTime34.getSecondOfMinute();
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:13.584Z" + "'", str12, "2020-11-25T01:49:13.584Z");
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 7 + "'", int17 == 7);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:13.584Z" + "'", str28, "2020-11-25T01:49:13.584Z");
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 20 + "'", int29 == 20);
org.junit.Assert.assertNotNull(chronology30);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 0 + "'", int39 == 0);
}
@Test
public void test1818() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1818");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
boolean boolean1 = mutableDateTime0.isAfterNow();
org.joda.time.DateTimeZone dateTimeZone2 = mutableDateTime0.getZone();
org.junit.Assert.assertTrue("'" + boolean1 + "' != '" + false + "'", boolean1 == false);
org.junit.Assert.assertNotNull(dateTimeZone2);
}
@Test
@Ignore
public void test1819() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1819");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property3.add((long) (short) -1);
java.util.Locale locale6 = null;
int int7 = property3.getMaximumShortTextLength(locale6);
long long8 = property3.remainder();
org.joda.time.MutableDateTime mutableDateTime9 = property3.getMutableDateTime();
int int10 = mutableDateTime9.getWeekOfWeekyear();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 3 + "'", int7 == 3);
org.junit.Assert.assertTrue("'" + long8 + "' != '" + 1L + "'", long8 == 1L);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 1 + "'", int10 == 1);
}
@Test
@Ignore
public void test1820() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1820");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.DateTimeZone dateTimeZone6 = mutableDateTime5.getZone();
mutableDateTime5.setMinuteOfDay(4);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
int int14 = mutableDateTime11.getYearOfCentury();
org.joda.time.Chronology chronology15 = mutableDateTime11.getChronology();
int int16 = mutableDateTime11.getWeekOfWeekyear();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.DateTimeZone dateTimeZone20 = mutableDateTime19.getZone();
org.joda.time.DateTime dateTime21 = mutableDateTime11.toDateTime(dateTimeZone20);
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime5.toMutableDateTime(dateTimeZone20);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = org.joda.time.MutableDateTime.now(chronology29);
boolean boolean31 = mutableDateTime22.isAfter((org.joda.time.ReadableInstant) mutableDateTime30);
boolean boolean32 = property2.equals((java.lang.Object) boolean31);
int int33 = property2.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime34 = property2.roundHalfFloor();
mutableDateTime34.addMillis(2189);
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property38 = mutableDateTime37.dayOfMonth();
org.joda.time.MutableDateTime.Property property39 = mutableDateTime37.dayOfMonth();
java.lang.String str40 = property39.getAsString();
org.joda.time.Interval interval41 = property39.toInterval();
java.lang.Object obj42 = null;
org.joda.time.Chronology chronology43 = null;
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(obj42, chronology43);
org.joda.time.format.DateTimeFormatter dateTimeFormatter45 = null;
java.lang.String str46 = mutableDateTime44.toString(dateTimeFormatter45);
org.joda.time.ReadablePeriod readablePeriod47 = null;
mutableDateTime44.add(readablePeriod47);
org.joda.time.MutableDateTime.Property property49 = mutableDateTime44.centuryOfEra();
boolean boolean50 = property39.equals((java.lang.Object) mutableDateTime44);
org.joda.time.MutableDateTime mutableDateTime52 = property39.addWrapField(28);
mutableDateTime34.setDate((org.joda.time.ReadableInstant) mutableDateTime52);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(dateTimeZone6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:13.697Z" + "'", str13, "2020-11-25T01:49:13.697Z");
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 20 + "'", int14 == 20);
org.junit.Assert.assertNotNull(chronology15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 48 + "'", int16 == 48);
org.junit.Assert.assertNotNull(dateTimeZone20);
org.junit.Assert.assertNotNull(dateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:13.697Z" + "'", str27, "2020-11-25T01:49:13.697Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 1 + "'", int33 == 1);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertNotNull(property38);
org.junit.Assert.assertNotNull(property39);
org.junit.Assert.assertEquals("'" + str40 + "' != '" + "25" + "'", str40, "25");
org.junit.Assert.assertNotNull(interval41);
// flaky: org.junit.Assert.assertEquals("'" + str46 + "' != '" + "2020-11-25T01:49:13.697Z" + "'", str46, "2020-11-25T01:49:13.697Z");
org.junit.Assert.assertNotNull(property49);
org.junit.Assert.assertTrue("'" + boolean50 + "' != '" + false + "'", boolean50 == false);
org.junit.Assert.assertNotNull(mutableDateTime52);
}
@Test
@Ignore
public void test1821() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1821");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property6 = mutableDateTime3.minuteOfDay();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime3.year();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime10.dayOfWeek();
int int17 = property16.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime19 = property16.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime20 = property16.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime20.add(readablePeriod21, 40);
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.format.DateTimeFormatter dateTimeFormatter27 = null;
java.lang.String str28 = mutableDateTime26.toString(dateTimeFormatter27);
int int29 = mutableDateTime26.getYearOfCentury();
org.joda.time.Chronology chronology30 = mutableDateTime26.getChronology();
org.joda.time.MutableDateTime mutableDateTime31 = mutableDateTime20.toMutableDateTime(chronology30);
mutableDateTime3.setChronology(chronology30);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(chronology30);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj0, chronology30);
mutableDateTime34.addMillis(11);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime34.dayOfWeek();
org.joda.time.ReadablePartial readablePartial38 = null;
// The following exception was thrown during execution in test generation
try {
int int39 = property37.compareTo(readablePartial38);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: The partial must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:13.774Z" + "'", str12, "2020-11-25T01:49:13.774Z");
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 7 + "'", int17 == 7);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:13.774Z" + "'", str28, "2020-11-25T01:49:13.774Z");
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 20 + "'", int29 == 20);
org.junit.Assert.assertNotNull(chronology30);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(property37);
}
@Test
public void test1822() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1822");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
java.util.Locale locale10 = null;
int int11 = property8.getMaximumShortTextLength(locale10);
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime((java.lang.Object) locale10);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:13.818Z" + "'", str4, "2020-11-25T01:49:13.818Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
}
@Test
public void test1823() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1823");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
boolean boolean10 = property7.isLeap();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:13.851Z" + "'", str4, "2020-11-25T01:49:13.851Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
}
@Test
@Ignore
public void test1824() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1824");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.setMonthOfYear((int) (byte) 10);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
java.lang.Object obj8 = mutableDateTime2.clone();
org.joda.time.MutableDateTime mutableDateTime9 = org.joda.time.MutableDateTime.now();
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(0L);
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.format.DateTimeFormatter dateTimeFormatter15 = null;
java.lang.String str16 = mutableDateTime14.toString(dateTimeFormatter15);
org.joda.time.ReadablePeriod readablePeriod17 = null;
mutableDateTime14.add(readablePeriod17);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime14.hourOfDay();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime14.dayOfWeek();
int int21 = property20.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime22 = property20.roundHalfCeiling();
org.joda.time.DateTimeField dateTimeField23 = property20.getField();
mutableDateTime11.setRounding(dateTimeField23);
int int25 = mutableDateTime9.get(dateTimeField23);
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setRounding(dateTimeField23, 627);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal rounding mode: 627");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(obj8);
// flaky: org.junit.Assert.assertEquals(obj8.toString(), "2020-10-25T01:49:13.877Z");
// flaky: org.junit.Assert.assertEquals(java.lang.String.valueOf(obj8), "2020-10-25T01:49:13.877Z");
// flaky: org.junit.Assert.assertEquals(java.util.Objects.toString(obj8), "2020-10-25T01:49:13.877Z");
org.junit.Assert.assertNotNull(mutableDateTime9);
// flaky: org.junit.Assert.assertEquals("'" + str16 + "' != '" + "2020-11-25T01:49:13.878Z" + "'", str16, "2020-11-25T01:49:13.878Z");
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 7 + "'", int21 == 7);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(dateTimeField23);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 3 + "'", int25 == 3);
}
@Test
public void test1825() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1825");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
org.joda.time.DurationField durationField3 = property2.getLeapDurationField();
java.lang.String str4 = property2.getAsString();
org.joda.time.MutableDateTime mutableDateTime5 = property2.getMutableDateTime();
org.joda.time.Interval interval6 = property2.toInterval();
int int7 = property2.get();
org.joda.time.MutableDateTime mutableDateTime9 = property2.add(6389);
mutableDateTime9.setMinuteOfDay(787);
mutableDateTime9.setMillis(179248677L);
mutableDateTime9.setDayOfYear(263);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(durationField3);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "1970" + "'", str4, "1970");
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(interval6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 1970 + "'", int7 == 1970);
org.junit.Assert.assertNotNull(mutableDateTime9);
}
@Test
@Ignore
public void test1826() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1826");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
int int6 = mutableDateTime3.getYearOfCentury();
org.joda.time.Chronology chronology7 = mutableDateTime3.getChronology();
int int8 = mutableDateTime3.getWeekOfWeekyear();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.DateTimeZone dateTimeZone12 = mutableDateTime11.getZone();
org.joda.time.DateTime dateTime13 = mutableDateTime3.toDateTime(dateTimeZone12);
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((-1L), dateTimeZone12);
org.joda.time.DateTime dateTime15 = mutableDateTime14.toDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime17.weekyear();
int int19 = mutableDateTime17.getDayOfWeek();
boolean boolean20 = dateTime15.isAfter((org.joda.time.ReadableInstant) mutableDateTime17);
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime17.add(readablePeriod21, 653);
java.lang.Object obj24 = null;
org.joda.time.Chronology chronology25 = null;
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(obj24, chronology25);
org.joda.time.format.DateTimeFormatter dateTimeFormatter27 = null;
java.lang.String str28 = mutableDateTime26.toString(dateTimeFormatter27);
int int29 = mutableDateTime26.getYearOfCentury();
org.joda.time.Chronology chronology30 = mutableDateTime26.getChronology();
int int31 = mutableDateTime26.getDayOfWeek();
org.joda.time.MutableDateTime.Property property32 = mutableDateTime26.centuryOfEra();
int int33 = mutableDateTime17.compareTo((org.joda.time.ReadableInstant) mutableDateTime26);
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:13.942Z" + "'", str5, "2020-11-25T01:49:13.942Z");
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 20 + "'", int6 == 20);
org.junit.Assert.assertNotNull(chronology7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 48 + "'", int8 == 48);
org.junit.Assert.assertNotNull(dateTimeZone12);
org.junit.Assert.assertNotNull(dateTime13);
org.junit.Assert.assertNotNull(dateTime15);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 4 + "'", int19 == 4);
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:13.942Z" + "'", str28, "2020-11-25T01:49:13.942Z");
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 20 + "'", int29 == 20);
org.junit.Assert.assertNotNull(chronology30);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 3 + "'", int31 == 3);
org.junit.Assert.assertNotNull(property32);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + (-1) + "'", int33 == (-1));
}
@Test
public void test1827() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1827");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
int int17 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime11);
java.util.Date date18 = mutableDateTime11.toDate();
int int19 = mutableDateTime11.getCenturyOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:13.991Z" + "'", str4, "2020-11-25T01:49:13.991Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:13.991Z" + "'", str13, "2020-11-25T01:49:13.991Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 0 + "'", int17 == 0);
org.junit.Assert.assertNotNull(date18);
// flaky: org.junit.Assert.assertEquals(date18.toString(), "Wed Nov 25 01:49:13 UTC 2020");
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 20 + "'", int19 == 20);
}
@Test
@Ignore
public void test1828() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1828");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime10 = property9.roundCeiling();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.year();
int int12 = mutableDateTime10.getDayOfMonth();
// The following exception was thrown during execution in test generation
try {
mutableDateTime10.setDayOfYear(912);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 912 for dayOfYear must be in the range [1,366]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.026Z" + "'", str4, "2020-11-25T01:49:14.026Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 25 + "'", int12 == 25);
}
@Test
@Ignore
public void test1829() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1829");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.year();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
mutableDateTime2.setChronology(chronology29);
java.lang.Object obj32 = mutableDateTime2.clone();
org.joda.time.MutableDateTime mutableDateTime33 = mutableDateTime2.toMutableDateTime();
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property6);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:14.070Z" + "'", str11, "2020-11-25T01:49:14.070Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:14.070Z" + "'", str27, "2020-11-25T01:49:14.070Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(obj32);
org.junit.Assert.assertEquals(obj32.toString(), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj32), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj32), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertNotNull(mutableDateTime33);
}
@Test
@Ignore
public void test1830() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1830");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
mutableDateTime2.setMinuteOfDay(4);
java.lang.Object obj6 = null;
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime(obj6, chronology7);
org.joda.time.format.DateTimeFormatter dateTimeFormatter9 = null;
java.lang.String str10 = mutableDateTime8.toString(dateTimeFormatter9);
int int11 = mutableDateTime8.getYearOfCentury();
org.joda.time.Chronology chronology12 = mutableDateTime8.getChronology();
int int13 = mutableDateTime8.getWeekOfWeekyear();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.DateTimeZone dateTimeZone17 = mutableDateTime16.getZone();
org.joda.time.DateTime dateTime18 = mutableDateTime8.toDateTime(dateTimeZone17);
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime2.toMutableDateTime(dateTimeZone17);
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime19.toMutableDateTime();
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.weekyear();
long long24 = property23.remainder();
org.joda.time.DateTimeField dateTimeField25 = property23.getField();
org.joda.time.MutableDateTime mutableDateTime27 = property23.add(1L);
mutableDateTime27.setDayOfYear((int) (short) 100);
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology31);
org.joda.time.MutableDateTime.Property property33 = mutableDateTime32.dayOfYear();
int int34 = property33.get();
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
org.joda.time.ReadablePeriod readablePeriod40 = null;
mutableDateTime37.add(readablePeriod40);
org.joda.time.MutableDateTime.Property property42 = mutableDateTime37.centuryOfEra();
org.joda.time.ReadableInstant readableInstant43 = null;
mutableDateTime37.setDate(readableInstant43);
org.joda.time.MutableDateTime mutableDateTime45 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property46 = mutableDateTime45.dayOfMonth();
int int47 = mutableDateTime45.getCenturyOfEra();
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology49);
mutableDateTime50.setSecondOfMinute((int) '4');
int int53 = mutableDateTime50.getMinuteOfDay();
int int54 = mutableDateTime50.getCenturyOfEra();
java.lang.Object obj55 = null;
org.joda.time.Chronology chronology56 = null;
org.joda.time.MutableDateTime mutableDateTime57 = new org.joda.time.MutableDateTime(obj55, chronology56);
int int58 = mutableDateTime57.getDayOfWeek();
java.lang.Object obj59 = null;
org.joda.time.Chronology chronology60 = null;
org.joda.time.MutableDateTime mutableDateTime61 = new org.joda.time.MutableDateTime(obj59, chronology60);
org.joda.time.DateTimeZone dateTimeZone62 = mutableDateTime61.getZone();
org.joda.time.MutableDateTime mutableDateTime63 = org.joda.time.MutableDateTime.now(dateTimeZone62);
mutableDateTime57.setZoneRetainFields(dateTimeZone62);
org.joda.time.DateTime dateTime65 = mutableDateTime50.toDateTime(dateTimeZone62);
mutableDateTime45.setZoneRetainFields(dateTimeZone62);
mutableDateTime37.setZone(dateTimeZone62);
org.joda.time.MutableDateTime mutableDateTime68 = org.joda.time.MutableDateTime.now(dateTimeZone62);
long long69 = property33.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime68);
org.joda.time.MutableDateTime mutableDateTime70 = property33.roundCeiling();
int int71 = mutableDateTime27.compareTo((org.joda.time.ReadableInstant) mutableDateTime70);
mutableDateTime70.setYear(2);
java.util.GregorianCalendar gregorianCalendar74 = mutableDateTime70.toGregorianCalendar();
mutableDateTime70.setYear(6386);
boolean boolean78 = mutableDateTime70.isAfter((long) 23);
mutableDateTime20.setTime((org.joda.time.ReadableInstant) mutableDateTime70);
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertEquals("'" + str10 + "' != '" + "2020-11-25T01:49:14.122Z" + "'", str10, "2020-11-25T01:49:14.122Z");
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 20 + "'", int11 == 20);
org.junit.Assert.assertNotNull(chronology12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 48 + "'", int13 == 48);
org.junit.Assert.assertNotNull(dateTimeZone17);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + long24 + "' != '" + 259200010L + "'", long24 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField25);
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertNotNull(property33);
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 1 + "'", int34 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:14.122Z" + "'", str39, "2020-11-25T01:49:14.122Z");
org.junit.Assert.assertNotNull(property42);
org.junit.Assert.assertNotNull(property46);
org.junit.Assert.assertTrue("'" + int47 + "' != '" + 20 + "'", int47 == 20);
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 0 + "'", int53 == 0);
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 19 + "'", int54 == 19);
org.junit.Assert.assertTrue("'" + int58 + "' != '" + 3 + "'", int58 == 3);
org.junit.Assert.assertNotNull(dateTimeZone62);
org.junit.Assert.assertNotNull(mutableDateTime63);
org.junit.Assert.assertNotNull(dateTime65);
org.junit.Assert.assertNotNull(mutableDateTime68);
org.junit.Assert.assertTrue("'" + long69 + "' != '" + (-18591L) + "'", long69 == (-18591L));
org.junit.Assert.assertNotNull(mutableDateTime70);
org.junit.Assert.assertTrue("'" + int71 + "' != '" + 1 + "'", int71 == 1);
org.junit.Assert.assertNotNull(gregorianCalendar74);
org.junit.Assert.assertTrue("'" + boolean78 + "' != '" + true + "'", boolean78 == true);
}
@Test
public void test1831() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1831");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
org.joda.time.MutableDateTime mutableDateTime10 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.minuteOfDay();
java.lang.String str12 = property11.getAsText();
org.joda.time.DateTimeField dateTimeField13 = property11.getField();
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime((java.lang.Object) property11);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: No instant converter found for type: org.joda.time.MutableDateTime$Property");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertEquals("'" + str12 + "' != '" + "0" + "'", str12, "0");
org.junit.Assert.assertNotNull(dateTimeField13);
}
@Test
@Ignore
public void test1832() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1832");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
int int10 = property9.getMaximumValueOverall();
java.lang.String str11 = property9.getAsText();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
int int15 = mutableDateTime14.getDayOfWeek();
mutableDateTime14.addSeconds((int) (byte) 0);
mutableDateTime14.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime14);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime14.toString(dateTimeFormatter21);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
org.joda.time.ReadablePeriod readablePeriod28 = null;
mutableDateTime25.add(readablePeriod28);
org.joda.time.MutableDateTime.Property property30 = mutableDateTime25.centuryOfEra();
org.joda.time.DateTimeField dateTimeField31 = property30.getField();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.format.DateTimeFormatter dateTimeFormatter35 = null;
java.lang.String str36 = mutableDateTime34.toString(dateTimeFormatter35);
org.joda.time.ReadablePeriod readablePeriod37 = null;
mutableDateTime34.add(readablePeriod37);
org.joda.time.MutableDateTime.Property property39 = mutableDateTime34.centuryOfEra();
int int40 = property30.getDifference((org.joda.time.ReadableInstant) mutableDateTime34);
org.joda.time.MutableDateTime mutableDateTime41 = mutableDateTime34.toMutableDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime42 = mutableDateTime34.toMutableDateTimeISO();
org.joda.time.DateTime dateTime43 = mutableDateTime42.toDateTime();
mutableDateTime14.setDate((org.joda.time.ReadableInstant) mutableDateTime42);
boolean boolean45 = property9.equals((java.lang.Object) mutableDateTime42);
int int46 = mutableDateTime42.getDayOfYear();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.332Z" + "'", str4, "2020-11-25T01:49:14.332Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 86399 + "'", int10 == 86399);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "6554" + "'", str11, "6554");
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 3 + "'", int15 == 3);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-02-01T01:49:14.332Z" + "'", str22, "2020-02-01T01:49:14.332Z");
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:14.332Z" + "'", str27, "2020-11-25T01:49:14.332Z");
org.junit.Assert.assertNotNull(property30);
org.junit.Assert.assertNotNull(dateTimeField31);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:14.332Z" + "'", str36, "2020-11-25T01:49:14.332Z");
org.junit.Assert.assertNotNull(property39);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 0 + "'", int40 == 0);
org.junit.Assert.assertNotNull(mutableDateTime41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime43);
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + false + "'", boolean45 == false);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 330 + "'", int46 == 330);
}
@Test
@Ignore
public void test1833() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1833");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime13 = property11.add((long) (short) -1);
mutableDateTime13.setWeekOfWeekyear((int) '4');
mutableDateTime7.setTime((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.secondOfDay();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
org.joda.time.ReadablePeriod readablePeriod23 = null;
mutableDateTime20.add(readablePeriod23);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime20.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType26 = property25.getFieldType();
boolean boolean27 = property17.equals((java.lang.Object) dateTimeFieldType26);
org.joda.time.MutableDateTime mutableDateTime28 = property17.roundHalfFloor();
int int29 = property17.getLeapAmount();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.378Z" + "'", str4, "2020-11-25T01:49:14.378Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:14.378Z" + "'", str22, "2020-11-25T01:49:14.378Z");
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertNotNull(dateTimeFieldType26);
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + false + "'", boolean27 == false);
org.junit.Assert.assertNotNull(mutableDateTime28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 0 + "'", int29 == 0);
}
@Test
@Ignore
public void test1834() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1834");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
mutableDateTime9.addDays(19);
org.joda.time.ReadableDuration readableDuration19 = null;
mutableDateTime9.add(readableDuration19);
int int21 = mutableDateTime9.getDayOfMonth();
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
int int25 = mutableDateTime24.getDayOfWeek();
mutableDateTime24.addSeconds((int) (byte) 0);
mutableDateTime24.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime24);
long long31 = mutableDateTime30.getMillis();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.format.DateTimeFormatter dateTimeFormatter35 = null;
java.lang.String str36 = mutableDateTime34.toString(dateTimeFormatter35);
org.joda.time.ReadablePeriod readablePeriod37 = null;
mutableDateTime34.add(readablePeriod37);
org.joda.time.MutableDateTime.Property property39 = mutableDateTime34.centuryOfEra();
org.joda.time.ReadableInstant readableInstant40 = null;
mutableDateTime34.setDate(readableInstant40);
org.joda.time.MutableDateTime mutableDateTime42 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property43 = mutableDateTime42.dayOfMonth();
int int44 = mutableDateTime42.getCenturyOfEra();
org.joda.time.Chronology chronology46 = null;
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology46);
mutableDateTime47.setSecondOfMinute((int) '4');
int int50 = mutableDateTime47.getMinuteOfDay();
int int51 = mutableDateTime47.getCenturyOfEra();
java.lang.Object obj52 = null;
org.joda.time.Chronology chronology53 = null;
org.joda.time.MutableDateTime mutableDateTime54 = new org.joda.time.MutableDateTime(obj52, chronology53);
int int55 = mutableDateTime54.getDayOfWeek();
java.lang.Object obj56 = null;
org.joda.time.Chronology chronology57 = null;
org.joda.time.MutableDateTime mutableDateTime58 = new org.joda.time.MutableDateTime(obj56, chronology57);
org.joda.time.DateTimeZone dateTimeZone59 = mutableDateTime58.getZone();
org.joda.time.MutableDateTime mutableDateTime60 = org.joda.time.MutableDateTime.now(dateTimeZone59);
mutableDateTime54.setZoneRetainFields(dateTimeZone59);
org.joda.time.DateTime dateTime62 = mutableDateTime47.toDateTime(dateTimeZone59);
mutableDateTime42.setZoneRetainFields(dateTimeZone59);
mutableDateTime34.setZone(dateTimeZone59);
org.joda.time.DateTime dateTime65 = mutableDateTime30.toDateTime(dateTimeZone59);
org.joda.time.MutableDateTime mutableDateTime66 = new org.joda.time.MutableDateTime(dateTimeZone59);
int int67 = mutableDateTime66.getDayOfWeek();
boolean boolean68 = mutableDateTime9.isBefore((org.joda.time.ReadableInstant) mutableDateTime66);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.412Z" + "'", str4, "2020-11-25T01:49:14.412Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:14.412Z" + "'", str11, "2020-11-25T01:49:14.412Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:14.412Z" + "'", str15, "2020-11-25T01:49:14.412Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 14 + "'", int21 == 14);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 3 + "'", int25 == 3);
// flaky: org.junit.Assert.assertTrue("'" + long31 + "' != '" + 1580521754412L + "'", long31 == 1580521754412L);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:14.412Z" + "'", str36, "2020-11-25T01:49:14.412Z");
org.junit.Assert.assertNotNull(property39);
org.junit.Assert.assertNotNull(property43);
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 20 + "'", int44 == 20);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 0 + "'", int50 == 0);
org.junit.Assert.assertTrue("'" + int51 + "' != '" + 19 + "'", int51 == 19);
org.junit.Assert.assertTrue("'" + int55 + "' != '" + 3 + "'", int55 == 3);
org.junit.Assert.assertNotNull(dateTimeZone59);
org.junit.Assert.assertNotNull(mutableDateTime60);
org.junit.Assert.assertNotNull(dateTime62);
org.junit.Assert.assertNotNull(dateTime65);
org.junit.Assert.assertTrue("'" + int67 + "' != '" + 3 + "'", int67 == 3);
org.junit.Assert.assertTrue("'" + boolean68 + "' != '" + false + "'", boolean68 == false);
}
@Test
@Ignore
public void test1835() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1835");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime3 = property2.getMutableDateTime();
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime((long) 365, dateTimeZone4);
int int6 = mutableDateTime5.getHourOfDay();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime9.secondOfDay();
org.joda.time.ReadableDuration readableDuration17 = null;
mutableDateTime9.add(readableDuration17);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime9.centuryOfEra();
boolean boolean20 = mutableDateTime9.isBeforeNow();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime9.millisOfSecond();
org.joda.time.MutableDateTime mutableDateTime22 = mutableDateTime9.toMutableDateTime();
boolean boolean23 = mutableDateTime5.isBefore((org.joda.time.ReadableInstant) mutableDateTime9);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(mutableDateTime3);
org.junit.Assert.assertNotNull(dateTimeZone4);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 0 + "'", int6 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:14.490Z" + "'", str11, "2020-11-25T01:49:14.490Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + true + "'", boolean23 == true);
}
@Test
@Ignore
public void test1836() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1836");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
int int9 = property8.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime10 = property8.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.millisOfSecond();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime10.yearOfCentury();
int int13 = property12.getMaximumValueOverall();
int int14 = property12.getLeapAmount();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.format.DateTimeFormatter dateTimeFormatter18 = null;
java.lang.String str19 = mutableDateTime17.toString(dateTimeFormatter18);
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime17.add(readablePeriod20);
org.joda.time.MutableDateTime.Property property22 = mutableDateTime17.yearOfCentury();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime17.dayOfWeek();
org.joda.time.MutableDateTime.Property property24 = mutableDateTime17.millisOfDay();
org.joda.time.ReadablePeriod readablePeriod25 = null;
mutableDateTime17.add(readablePeriod25);
int int27 = property12.compareTo((org.joda.time.ReadableInstant) mutableDateTime17);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 99 + "'", int13 == 99);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str19 + "' != '" + "2020-11-25T01:49:14.545Z" + "'", str19, "2020-11-25T01:49:14.545Z");
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertNotNull(property24);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 0 + "'", int27 == 0);
}
@Test
public void test1837() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1837");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
java.util.GregorianCalendar gregorianCalendar6 = mutableDateTime5.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.millisOfDay();
java.util.GregorianCalendar gregorianCalendar8 = mutableDateTime5.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime5.millisOfDay();
org.joda.time.DurationField durationField10 = property9.getLeapDurationField();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(gregorianCalendar6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(gregorianCalendar8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNull(durationField10);
}
@Test
@Ignore
public void test1838() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1838");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.Locale locale4 = null;
java.lang.String str5 = property3.getAsText(locale4);
org.joda.time.DurationField durationField6 = property3.getLeapDurationField();
org.joda.time.MutableDateTime mutableDateTime7 = property3.roundHalfEven();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.Instant instant11 = mutableDateTime10.toInstant();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime10.monthOfYear();
mutableDateTime10.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.secondOfMinute();
int int16 = property15.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime17 = property15.roundHalfEven();
org.joda.time.DateTime dateTime18 = mutableDateTime17.toDateTimeISO();
int int19 = property3.getDifference((org.joda.time.ReadableInstant) dateTime18);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertEquals("'" + str5 + "' != '" + "1" + "'", str5, "1");
org.junit.Assert.assertNull(durationField6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(instant11);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 59 + "'", int16 == 59);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + (-18691) + "'", int19 == (-18691));
}
@Test
@Ignore
public void test1839() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1839");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
org.joda.time.DurationField durationField10 = property8.getDurationField();
java.lang.String str11 = property8.getAsShortText();
org.joda.time.DurationField durationField12 = property8.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime13 = property8.getMutableDateTime();
org.joda.time.MutableDateTime mutableDateTime14 = mutableDateTime13.copy();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.665Z" + "'", str4, "2020-11-25T01:49:14.665Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Wed" + "'", str11, "Wed");
org.junit.Assert.assertNotNull(durationField12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(mutableDateTime14);
}
@Test
public void test1840() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1840");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime10 = property8.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
long long12 = property11.remainder();
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime14 = property11.set("2020-11-25T01:44:54.628Z");
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value \"2020-11-25T01:44:54.628Z\" for dayOfYear is not supported");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.700Z" + "'", str4, "2020-11-25T01:49:14.700Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertTrue("'" + long12 + "' != '" + 0L + "'", long12 == 0L);
}
@Test
@Ignore
public void test1841() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1841");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.DateTimeField dateTimeField4 = property2.getField();
org.joda.time.MutableDateTime mutableDateTime6 = property2.add(1L);
mutableDateTime6.setDayOfYear((int) (short) 100);
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfYear();
int int13 = property12.get();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.centuryOfEra();
org.joda.time.ReadableInstant readableInstant22 = null;
mutableDateTime16.setDate(readableInstant22);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfMonth();
int int26 = mutableDateTime24.getCenturyOfEra();
org.joda.time.Chronology chronology28 = null;
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology28);
mutableDateTime29.setSecondOfMinute((int) '4');
int int32 = mutableDateTime29.getMinuteOfDay();
int int33 = mutableDateTime29.getCenturyOfEra();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
int int37 = mutableDateTime36.getDayOfWeek();
java.lang.Object obj38 = null;
org.joda.time.Chronology chronology39 = null;
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime(obj38, chronology39);
org.joda.time.DateTimeZone dateTimeZone41 = mutableDateTime40.getZone();
org.joda.time.MutableDateTime mutableDateTime42 = org.joda.time.MutableDateTime.now(dateTimeZone41);
mutableDateTime36.setZoneRetainFields(dateTimeZone41);
org.joda.time.DateTime dateTime44 = mutableDateTime29.toDateTime(dateTimeZone41);
mutableDateTime24.setZoneRetainFields(dateTimeZone41);
mutableDateTime16.setZone(dateTimeZone41);
org.joda.time.MutableDateTime mutableDateTime47 = org.joda.time.MutableDateTime.now(dateTimeZone41);
long long48 = property12.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime47);
org.joda.time.MutableDateTime mutableDateTime49 = property12.roundCeiling();
int int50 = mutableDateTime6.compareTo((org.joda.time.ReadableInstant) mutableDateTime49);
mutableDateTime49.setYear(2);
java.util.GregorianCalendar gregorianCalendar53 = mutableDateTime49.toGregorianCalendar();
mutableDateTime49.setYear(6386);
boolean boolean57 = mutableDateTime49.isAfter((long) 23);
java.lang.Object obj59 = null;
org.joda.time.Chronology chronology60 = null;
org.joda.time.MutableDateTime mutableDateTime61 = new org.joda.time.MutableDateTime(obj59, chronology60);
org.joda.time.format.DateTimeFormatter dateTimeFormatter62 = null;
java.lang.String str63 = mutableDateTime61.toString(dateTimeFormatter62);
org.joda.time.ReadablePeriod readablePeriod64 = null;
mutableDateTime61.add(readablePeriod64);
org.joda.time.MutableDateTime.Property property66 = mutableDateTime61.hourOfDay();
org.joda.time.MutableDateTime.Property property67 = mutableDateTime61.dayOfWeek();
int int68 = property67.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime70 = property67.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime71 = property67.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod72 = null;
mutableDateTime71.add(readablePeriod72, 40);
java.lang.Object obj75 = null;
org.joda.time.Chronology chronology76 = null;
org.joda.time.MutableDateTime mutableDateTime77 = new org.joda.time.MutableDateTime(obj75, chronology76);
org.joda.time.format.DateTimeFormatter dateTimeFormatter78 = null;
java.lang.String str79 = mutableDateTime77.toString(dateTimeFormatter78);
int int80 = mutableDateTime77.getYearOfCentury();
org.joda.time.Chronology chronology81 = mutableDateTime77.getChronology();
org.joda.time.MutableDateTime mutableDateTime82 = mutableDateTime71.toMutableDateTime(chronology81);
org.joda.time.MutableDateTime mutableDateTime83 = new org.joda.time.MutableDateTime(6436228L, chronology81);
org.joda.time.MutableDateTime mutableDateTime84 = mutableDateTime49.toMutableDateTime(chronology81);
int int85 = mutableDateTime49.getMillisOfDay();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField4);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 1 + "'", int13 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:14.732Z" + "'", str18, "2020-11-25T01:49:14.732Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 0 + "'", int32 == 0);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 19 + "'", int33 == 19);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 3 + "'", int37 == 3);
org.junit.Assert.assertNotNull(dateTimeZone41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime44);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertTrue("'" + long48 + "' != '" + (-18591L) + "'", long48 == (-18591L));
org.junit.Assert.assertNotNull(mutableDateTime49);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 1 + "'", int50 == 1);
org.junit.Assert.assertNotNull(gregorianCalendar53);
org.junit.Assert.assertTrue("'" + boolean57 + "' != '" + true + "'", boolean57 == true);
// flaky: org.junit.Assert.assertEquals("'" + str63 + "' != '" + "2020-11-25T01:49:14.732Z" + "'", str63, "2020-11-25T01:49:14.732Z");
org.junit.Assert.assertNotNull(property66);
org.junit.Assert.assertNotNull(property67);
org.junit.Assert.assertTrue("'" + int68 + "' != '" + 7 + "'", int68 == 7);
org.junit.Assert.assertNotNull(mutableDateTime70);
org.junit.Assert.assertNotNull(mutableDateTime71);
// flaky: org.junit.Assert.assertEquals("'" + str79 + "' != '" + "2020-11-25T01:49:14.732Z" + "'", str79, "2020-11-25T01:49:14.732Z");
org.junit.Assert.assertTrue("'" + int80 + "' != '" + 20 + "'", int80 == 20);
org.junit.Assert.assertNotNull(chronology81);
org.junit.Assert.assertNotNull(mutableDateTime82);
org.junit.Assert.assertNotNull(mutableDateTime84);
org.junit.Assert.assertTrue("'" + int85 + "' != '" + 0 + "'", int85 == 0);
}
@Test
@Ignore
public void test1842() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1842");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime2.minuteOfDay();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime19.add(readablePeriod22);
org.joda.time.MutableDateTime.Property property24 = mutableDateTime19.centuryOfEra();
int int25 = property24.get();
org.joda.time.MutableDateTime mutableDateTime27 = property24.addWrapField(6300);
long long28 = property16.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime27);
int int29 = mutableDateTime27.getYearOfEra();
org.joda.time.MutableDateTime.Property property30 = mutableDateTime27.dayOfMonth();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.822Z" + "'", str4, "2020-11-25T01:49:14.822Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:14.822Z" + "'", str21, "2020-11-25T01:49:14.822Z");
org.junit.Assert.assertNotNull(property24);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 20 + "'", int25 == 20);
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertTrue("'" + long28 + "' != '" + (-331347996000L) + "'", long28 == (-331347996000L));
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 632020 + "'", int29 == 632020);
org.junit.Assert.assertNotNull(property30);
}
@Test
@Ignore
public void test1843() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1843");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
int int4 = mutableDateTime2.getSecondOfMinute();
int int5 = mutableDateTime2.getMonthOfYear();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setMinuteOfHour(6351);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6351 for minuteOfHour must be in the range [0,59]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 14 + "'", int4 == 14);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 11 + "'", int5 == 11);
org.junit.Assert.assertNotNull(chronology6);
}
@Test
@Ignore
public void test1844() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1844");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
int int13 = mutableDateTime10.getYearOfCentury();
org.joda.time.Chronology chronology14 = mutableDateTime10.getChronology();
org.joda.time.MutableDateTime mutableDateTime15 = mutableDateTime2.toMutableDateTime(chronology14);
mutableDateTime2.add((long) 6353);
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
org.joda.time.ReadablePeriod readablePeriod23 = null;
mutableDateTime20.add(readablePeriod23);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime20.hourOfDay();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime20.dayOfWeek();
int int27 = property26.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime28 = property26.roundHalfCeiling();
org.joda.time.DateTimeField dateTimeField29 = property26.getField();
int int30 = property26.getMinimumValueOverall();
org.joda.time.MutableDateTime mutableDateTime31 = property26.roundFloor();
org.joda.time.Chronology chronology32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = mutableDateTime31.toMutableDateTime(chronology32);
boolean boolean34 = mutableDateTime2.isBefore((org.joda.time.ReadableInstant) mutableDateTime33);
java.lang.Object obj35 = mutableDateTime33.clone();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:14.890Z" + "'", str4, "2020-11-25T01:49:14.890Z");
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:14.890Z" + "'", str12, "2020-11-25T01:49:14.890Z");
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 20 + "'", int13 == 20);
org.junit.Assert.assertNotNull(chronology14);
org.junit.Assert.assertNotNull(mutableDateTime15);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:14.890Z" + "'", str22, "2020-11-25T01:49:14.890Z");
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 7 + "'", int27 == 7);
org.junit.Assert.assertNotNull(mutableDateTime28);
org.junit.Assert.assertNotNull(dateTimeField29);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 1 + "'", int30 == 1);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + false + "'", boolean34 == false);
org.junit.Assert.assertNotNull(obj35);
org.junit.Assert.assertEquals(obj35.toString(), "2020-11-25T00:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj35), "2020-11-25T00:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj35), "2020-11-25T00:00:00.000Z");
}
@Test
public void test1845() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1845");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
java.util.Locale locale10 = null;
int int11 = property8.getMaximumShortTextLength(locale10);
org.joda.time.MutableDateTime mutableDateTime13 = property8.addWrapField((int) (short) 1);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime13.centuryOfEra();
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime13.getZone();
boolean boolean16 = mutableDateTime13.isAfterNow();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:15.025Z" + "'", str4, "2020-11-25T01:49:15.025Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + true + "'", boolean16 == true);
}
@Test
@Ignore
public void test1846() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1846");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) 100, chronology29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology29);
int int34 = mutableDateTime2.getEra();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:15.072Z" + "'", str11, "2020-11-25T01:49:15.072Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:15.072Z" + "'", str27, "2020-11-25T01:49:15.072Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 1 + "'", int34 == 1);
}
@Test
public void test1847() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1847");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
long long6 = property5.remainder();
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertTrue("'" + long6 + "' != '" + 52001L + "'", long6 == 52001L);
}
@Test
@Ignore
public void test1848() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1848");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.yearOfCentury();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime3.millisOfDay();
mutableDateTime3.add((long) 3);
mutableDateTime3.addWeekyears((int) (byte) 100);
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime17.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime17.copy();
mutableDateTime3.setDate((org.joda.time.ReadableInstant) mutableDateTime17);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime17.weekOfWeekyear();
int int22 = mutableDateTime17.getRoundingMode();
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.DateTimeZone dateTimeZone26 = mutableDateTime25.getZone();
int int27 = mutableDateTime25.getSecondOfMinute();
int int28 = mutableDateTime25.getMonthOfYear();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
org.joda.time.ReadablePeriod readablePeriod35 = null;
mutableDateTime32.add(readablePeriod35);
org.joda.time.MutableDateTime.Property property37 = mutableDateTime32.centuryOfEra();
org.joda.time.ReadableInstant readableInstant38 = null;
mutableDateTime32.setDate(readableInstant38);
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property41 = mutableDateTime40.dayOfMonth();
int int42 = mutableDateTime40.getCenturyOfEra();
org.joda.time.Chronology chronology44 = null;
org.joda.time.MutableDateTime mutableDateTime45 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology44);
mutableDateTime45.setSecondOfMinute((int) '4');
int int48 = mutableDateTime45.getMinuteOfDay();
int int49 = mutableDateTime45.getCenturyOfEra();
java.lang.Object obj50 = null;
org.joda.time.Chronology chronology51 = null;
org.joda.time.MutableDateTime mutableDateTime52 = new org.joda.time.MutableDateTime(obj50, chronology51);
int int53 = mutableDateTime52.getDayOfWeek();
java.lang.Object obj54 = null;
org.joda.time.Chronology chronology55 = null;
org.joda.time.MutableDateTime mutableDateTime56 = new org.joda.time.MutableDateTime(obj54, chronology55);
org.joda.time.DateTimeZone dateTimeZone57 = mutableDateTime56.getZone();
org.joda.time.MutableDateTime mutableDateTime58 = org.joda.time.MutableDateTime.now(dateTimeZone57);
mutableDateTime52.setZoneRetainFields(dateTimeZone57);
org.joda.time.DateTime dateTime60 = mutableDateTime45.toDateTime(dateTimeZone57);
mutableDateTime40.setZoneRetainFields(dateTimeZone57);
mutableDateTime32.setZone(dateTimeZone57);
org.joda.time.MutableDateTime mutableDateTime63 = org.joda.time.MutableDateTime.now(dateTimeZone57);
org.joda.time.MutableDateTime mutableDateTime64 = mutableDateTime25.toMutableDateTime(dateTimeZone57);
org.joda.time.MutableDateTime mutableDateTime65 = mutableDateTime17.toMutableDateTime(dateTimeZone57);
org.joda.time.MutableDateTime mutableDateTime66 = new org.joda.time.MutableDateTime((long) '#', dateTimeZone57);
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:15.180Z" + "'", str5, "2020-11-25T01:49:15.180Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 0 + "'", int22 == 0);
org.junit.Assert.assertNotNull(dateTimeZone26);
// flaky: org.junit.Assert.assertTrue("'" + int27 + "' != '" + 15 + "'", int27 == 15);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 11 + "'", int28 == 11);
org.junit.Assert.assertNotNull(chronology29);
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:15.180Z" + "'", str34, "2020-11-25T01:49:15.180Z");
org.junit.Assert.assertNotNull(property37);
org.junit.Assert.assertNotNull(property41);
org.junit.Assert.assertTrue("'" + int42 + "' != '" + 20 + "'", int42 == 20);
org.junit.Assert.assertTrue("'" + int48 + "' != '" + 0 + "'", int48 == 0);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 19 + "'", int49 == 19);
org.junit.Assert.assertTrue("'" + int53 + "' != '" + 3 + "'", int53 == 3);
org.junit.Assert.assertNotNull(dateTimeZone57);
org.junit.Assert.assertNotNull(mutableDateTime58);
org.junit.Assert.assertNotNull(dateTime60);
org.junit.Assert.assertNotNull(mutableDateTime63);
org.junit.Assert.assertNotNull(mutableDateTime64);
org.junit.Assert.assertNotNull(mutableDateTime65);
}
@Test
@Ignore
public void test1849() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1849");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
int int8 = mutableDateTime2.getCenturyOfEra();
mutableDateTime2.add((long) 330);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime12 = property11.getMutableDateTime();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:15.261Z" + "'", str4, "2020-11-25T01:49:15.261Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 20 + "'", int8 == 20);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime12);
}
@Test
public void test1850() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1850");
java.lang.Object obj0 = null;
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
org.joda.time.MutableDateTime mutableDateTime5 = org.joda.time.MutableDateTime.now(dateTimeZone4);
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime(dateTimeZone4);
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj0, dateTimeZone4);
org.junit.Assert.assertNotNull(dateTimeZone4);
org.junit.Assert.assertNotNull(mutableDateTime5);
}
@Test
public void test1851() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1851");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
org.joda.time.MutableDateTime mutableDateTime7 = mutableDateTime2.toMutableDateTimeISO();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime7.weekOfWeekyear();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property8);
}
@Test
public void test1852() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1852");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
org.joda.time.MutableDateTime mutableDateTime10 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.minuteOfDay();
org.joda.time.MutableDateTime mutableDateTime12 = mutableDateTime10.copy();
java.util.Locale locale14 = null;
java.lang.String str15 = mutableDateTime10.toString("2020", locale14);
// The following exception was thrown during execution in test generation
try {
mutableDateTime10.setDayOfYear((-18691));
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value -18691 for dayOfYear must be in the range [1,365]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020" + "'", str15, "2020");
}
@Test
@Ignore
public void test1853() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1853");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
long long13 = property8.remainder();
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime14.dayOfMonth();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime14.dayOfMonth();
java.lang.String str17 = property16.getAsString();
org.joda.time.Interval interval18 = property16.toInterval();
boolean boolean19 = property8.equals((java.lang.Object) interval18);
org.joda.time.DurationField durationField20 = property8.getRangeDurationField();
org.joda.time.Interval interval21 = property8.toInterval();
long long22 = property8.remainder();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:15.524Z" + "'", str4, "2020-11-25T01:49:15.524Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertTrue("'" + long13 + "' != '" + 0L + "'", long13 == 0L);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "25" + "'", str17, "25");
org.junit.Assert.assertNotNull(interval18);
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + false + "'", boolean19 == false);
org.junit.Assert.assertNotNull(durationField20);
org.junit.Assert.assertNotNull(interval21);
org.junit.Assert.assertTrue("'" + long22 + "' != '" + 0L + "'", long22 == 0L);
}
@Test
@Ignore
public void test1854() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1854");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.centuryOfEra();
org.joda.time.ReadableInstant readableInstant9 = null;
mutableDateTime3.setDate(readableInstant9);
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfMonth();
int int13 = mutableDateTime11.getCenturyOfEra();
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology15);
mutableDateTime16.setSecondOfMinute((int) '4');
int int19 = mutableDateTime16.getMinuteOfDay();
int int20 = mutableDateTime16.getCenturyOfEra();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
int int24 = mutableDateTime23.getDayOfWeek();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.DateTimeZone dateTimeZone28 = mutableDateTime27.getZone();
org.joda.time.MutableDateTime mutableDateTime29 = org.joda.time.MutableDateTime.now(dateTimeZone28);
mutableDateTime23.setZoneRetainFields(dateTimeZone28);
org.joda.time.DateTime dateTime31 = mutableDateTime16.toDateTime(dateTimeZone28);
mutableDateTime11.setZoneRetainFields(dateTimeZone28);
mutableDateTime3.setZone(dateTimeZone28);
org.joda.time.MutableDateTime mutableDateTime34 = org.joda.time.MutableDateTime.now(dateTimeZone28);
org.joda.time.MutableDateTime mutableDateTime35 = new org.joda.time.MutableDateTime(0L, dateTimeZone28);
int int36 = mutableDateTime35.getYearOfCentury();
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
org.joda.time.format.DateTimeFormatter dateTimeFormatter40 = null;
java.lang.String str41 = mutableDateTime39.toString(dateTimeFormatter40);
org.joda.time.ReadablePeriod readablePeriod42 = null;
mutableDateTime39.add(readablePeriod42);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime39.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime45 = mutableDateTime39.toMutableDateTimeISO();
java.lang.Object obj46 = null;
org.joda.time.Chronology chronology47 = null;
org.joda.time.MutableDateTime mutableDateTime48 = new org.joda.time.MutableDateTime(obj46, chronology47);
org.joda.time.format.DateTimeFormatter dateTimeFormatter49 = null;
java.lang.String str50 = mutableDateTime48.toString(dateTimeFormatter49);
org.joda.time.ReadablePeriod readablePeriod51 = null;
mutableDateTime48.add(readablePeriod51);
org.joda.time.MutableDateTime.Property property53 = mutableDateTime48.centuryOfEra();
org.joda.time.DateTimeField dateTimeField54 = property53.getField();
int int55 = mutableDateTime39.get(dateTimeField54);
int int56 = mutableDateTime35.get(dateTimeField54);
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:15.664Z" + "'", str5, "2020-11-25T01:49:15.664Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 20 + "'", int13 == 20);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 0 + "'", int19 == 0);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 19 + "'", int20 == 19);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 3 + "'", int24 == 3);
org.junit.Assert.assertNotNull(dateTimeZone28);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(dateTime31);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertTrue("'" + int36 + "' != '" + 70 + "'", int36 == 70);
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:15.664Z" + "'", str41, "2020-11-25T01:49:15.664Z");
org.junit.Assert.assertNotNull(property44);
org.junit.Assert.assertNotNull(mutableDateTime45);
// flaky: org.junit.Assert.assertEquals("'" + str50 + "' != '" + "2020-11-25T01:49:15.664Z" + "'", str50, "2020-11-25T01:49:15.664Z");
org.junit.Assert.assertNotNull(property53);
org.junit.Assert.assertNotNull(dateTimeField54);
org.junit.Assert.assertTrue("'" + int55 + "' != '" + 20 + "'", int55 == 20);
org.junit.Assert.assertTrue("'" + int56 + "' != '" + 19 + "'", int56 == 19);
}
@Test
public void test1855() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1855");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.util.Locale locale6 = null;
java.lang.String str7 = property5.getAsShortText(locale6);
org.joda.time.MutableDateTime mutableDateTime8 = property5.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime10 = property5.add(59);
mutableDateTime10.addMonths(59630400);
org.joda.time.Chronology chronology13 = mutableDateTime10.getChronology();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Jan" + "'", str7, "Jan");
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(chronology13);
}
@Test
public void test1856() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1856");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.centuryOfEra();
mutableDateTime2.addHours(49);
org.joda.time.ReadablePeriod readablePeriod11 = null;
mutableDateTime2.add(readablePeriod11, 6533446);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:15.791Z" + "'", str4, "2020-11-25T01:49:15.791Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
}
@Test
@Ignore
public void test1857() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1857");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.Interval interval4 = property2.toInterval();
int int5 = property2.get();
org.joda.time.MutableDateTime mutableDateTime7 = property2.add((long) 565);
org.joda.time.DateTime dateTime8 = mutableDateTime7.toDateTime();
org.joda.time.ReadablePeriod readablePeriod9 = null;
mutableDateTime7.add(readablePeriod9);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(interval4);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 25 + "'", int5 == 25);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(dateTime8);
}
@Test
@Ignore
public void test1858() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1858");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
org.joda.time.DurationField durationField10 = property8.getDurationField();
java.lang.String str11 = property8.getAsShortText();
long long12 = property8.remainder();
org.joda.time.DurationField durationField13 = property8.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime14 = property8.roundHalfFloor();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:15.889Z" + "'", str4, "2020-11-25T01:49:15.889Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertEquals("'" + str11 + "' != '" + "Wed" + "'", str11, "Wed");
// flaky: org.junit.Assert.assertTrue("'" + long12 + "' != '" + 6555889L + "'", long12 == 6555889L);
org.junit.Assert.assertNotNull(durationField13);
org.junit.Assert.assertNotNull(mutableDateTime14);
}
@Test
@Ignore
public void test1859() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1859");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
java.lang.Object obj17 = mutableDateTime2.clone();
long long18 = mutableDateTime2.getMillis();
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology22);
mutableDateTime23.setSecondOfMinute((int) '4');
int int26 = mutableDateTime23.getMinuteOfDay();
int int27 = mutableDateTime23.getCenturyOfEra();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
int int31 = mutableDateTime30.getDayOfWeek();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
org.joda.time.DateTimeZone dateTimeZone35 = mutableDateTime34.getZone();
org.joda.time.MutableDateTime mutableDateTime36 = org.joda.time.MutableDateTime.now(dateTimeZone35);
mutableDateTime30.setZoneRetainFields(dateTimeZone35);
org.joda.time.DateTime dateTime38 = mutableDateTime23.toDateTime(dateTimeZone35);
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(259200010L, dateTimeZone35);
mutableDateTime19.setZone(dateTimeZone35);
org.joda.time.MutableDateTime mutableDateTime41 = org.joda.time.MutableDateTime.now(dateTimeZone35);
org.joda.time.MutableDateTime.Property property42 = mutableDateTime41.dayOfMonth();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:15.922Z" + "'", str4, "2020-11-25T01:49:15.922Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:15.922Z" + "'", str11, "2020-11-25T01:49:15.922Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:15.922Z" + "'", str15, "2020-11-25T01:49:15.922Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(obj17);
org.junit.Assert.assertEquals(obj17.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long18 + "' != '" + 1606262400035L + "'", long18 == 1606262400035L);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 0 + "'", int26 == 0);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 19 + "'", int27 == 19);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 3 + "'", int31 == 3);
org.junit.Assert.assertNotNull(dateTimeZone35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertNotNull(dateTime38);
org.junit.Assert.assertNotNull(mutableDateTime41);
org.junit.Assert.assertNotNull(property42);
}
@Test
public void test1860() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1860");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.centuryOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.DateTimeZone dateTimeZone14 = mutableDateTime13.getZone();
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone14);
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone14);
mutableDateTime16.setSecondOfMinute((int) (short) 0);
org.joda.time.ReadableDuration readableDuration19 = null;
mutableDateTime16.add(readableDuration19);
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime21.dayOfMonth();
boolean boolean24 = mutableDateTime21.isBefore((long) 9);
org.joda.time.Chronology chronology25 = mutableDateTime21.getChronology();
org.joda.time.MutableDateTime mutableDateTime26 = org.joda.time.MutableDateTime.now(chronology25);
mutableDateTime16.setChronology(chronology25);
mutableDateTime2.setChronology(chronology25);
org.joda.time.ReadablePeriod readablePeriod29 = null;
mutableDateTime2.add(readablePeriod29);
org.joda.time.MutableDateTime.Property property31 = mutableDateTime2.secondOfMinute();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.012Z" + "'", str4, "2020-11-25T01:49:16.012Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(dateTimeZone14);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
org.junit.Assert.assertNotNull(chronology25);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(property31);
}
@Test
public void test1861() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1861");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
java.util.Date date8 = mutableDateTime2.toDate();
java.lang.Object obj9 = mutableDateTime2.clone();
mutableDateTime2.addDays(52);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.062Z" + "'", str4, "2020-11-25T01:49:16.062Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(date8);
// flaky: org.junit.Assert.assertEquals(date8.toString(), "Wed Nov 25 01:49:16 UTC 2020");
org.junit.Assert.assertNotNull(obj9);
// flaky: org.junit.Assert.assertEquals(obj9.toString(), "2020-11-25T01:49:16.062Z");
// flaky: org.junit.Assert.assertEquals(java.lang.String.valueOf(obj9), "2020-11-25T01:49:16.062Z");
// flaky: org.junit.Assert.assertEquals(java.util.Objects.toString(obj9), "2020-11-25T01:49:16.062Z");
}
@Test
@Ignore
public void test1862() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1862");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
org.joda.time.DateTimeField dateTimeField19 = property18.getField();
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
org.joda.time.ReadablePeriod readablePeriod25 = null;
mutableDateTime22.add(readablePeriod25);
org.joda.time.MutableDateTime.Property property27 = mutableDateTime22.hourOfDay();
org.joda.time.MutableDateTime.Property property28 = mutableDateTime22.dayOfWeek();
int int29 = property28.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime31 = property28.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime32 = property28.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime32.add(readablePeriod33, 40);
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
int int41 = mutableDateTime38.getYearOfCentury();
org.joda.time.Chronology chronology42 = mutableDateTime38.getChronology();
org.joda.time.MutableDateTime mutableDateTime43 = mutableDateTime32.toMutableDateTime(chronology42);
org.joda.time.MutableDateTime mutableDateTime44 = org.joda.time.MutableDateTime.now(chronology42);
org.joda.time.MutableDateTime.Property property45 = mutableDateTime44.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime46 = mutableDateTime44.copy();
long long47 = property18.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime46);
java.util.Locale locale48 = null;
int int49 = property18.getMaximumTextLength(locale48);
org.joda.time.MutableDateTime mutableDateTime50 = property18.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime51 = property18.roundFloor();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.097Z" + "'", str4, "2020-11-25T01:49:16.097Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:16.097Z" + "'", str11, "2020-11-25T01:49:16.097Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:16.097Z" + "'", str15, "2020-11-25T01:49:16.097Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeField19);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:16.097Z" + "'", str24, "2020-11-25T01:49:16.097Z");
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 7 + "'", int29 == 7);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime32);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:16.097Z" + "'", str40, "2020-11-25T01:49:16.097Z");
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 20 + "'", int41 == 20);
org.junit.Assert.assertNotNull(chronology42);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(mutableDateTime44);
org.junit.Assert.assertNotNull(property45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertTrue("'" + long47 + "' != '" + 0L + "'", long47 == 0L);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 3 + "'", int49 == 3);
org.junit.Assert.assertNotNull(mutableDateTime50);
org.junit.Assert.assertNotNull(mutableDateTime51);
}
@Test
public void test1863() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1863");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) 'a');
mutableDateTime1.setDate((long) 20);
}
@Test
public void test1864() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1864");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
int int8 = property7.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
org.joda.time.DurationField durationField10 = property7.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime11 = property7.roundHalfFloor();
org.joda.time.DateTimeZone dateTimeZone12 = mutableDateTime11.getZone();
mutableDateTime11.setDayOfYear(35);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.181Z" + "'", str4, "2020-11-25T01:49:16.181Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(durationField10);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(dateTimeZone12);
}
@Test
public void test1865() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1865");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.addMillis((int) 'a');
int int5 = mutableDateTime2.getDayOfYear();
int int6 = mutableDateTime2.getYear();
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 1 + "'", int5 == 1);
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1970 + "'", int6 == 1970);
}
@Test
public void test1866() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1866");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType10 = property9.getFieldType();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField((int) '4');
java.lang.String str13 = property9.getName();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.230Z" + "'", str4, "2020-11-25T01:49:16.230Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(dateTimeFieldType10);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertEquals("'" + str13 + "' != '" + "secondOfDay" + "'", str13, "secondOfDay");
}
@Test
@Ignore
public void test1867() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1867");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
java.lang.String str18 = mutableDateTime2.toString();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
int int24 = mutableDateTime21.getYearOfCentury();
org.joda.time.Chronology chronology25 = mutableDateTime21.getChronology();
org.joda.time.ReadablePeriod readablePeriod26 = null;
mutableDateTime21.add(readablePeriod26);
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
mutableDateTime30.setTime((long) '#');
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
org.joda.time.ReadablePeriod readablePeriod40 = null;
mutableDateTime37.add(readablePeriod40);
org.joda.time.MutableDateTime.Property property42 = mutableDateTime37.hourOfDay();
java.lang.String str43 = mutableDateTime37.toString();
int int44 = mutableDateTime30.compareTo((org.joda.time.ReadableInstant) mutableDateTime37);
java.lang.Object obj45 = mutableDateTime30.clone();
long long46 = mutableDateTime30.getMillis();
java.lang.Object obj47 = null;
org.joda.time.Chronology chronology48 = null;
org.joda.time.MutableDateTime mutableDateTime49 = new org.joda.time.MutableDateTime(obj47, chronology48);
org.joda.time.format.DateTimeFormatter dateTimeFormatter50 = null;
java.lang.String str51 = mutableDateTime49.toString(dateTimeFormatter50);
org.joda.time.ReadablePeriod readablePeriod52 = null;
mutableDateTime49.add(readablePeriod52);
org.joda.time.MutableDateTime.Property property54 = mutableDateTime49.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType55 = property54.getFieldType();
int int56 = mutableDateTime30.get(dateTimeFieldType55);
org.joda.time.MutableDateTime.Property property57 = mutableDateTime21.property(dateTimeFieldType55);
boolean boolean58 = mutableDateTime2.isSupported(dateTimeFieldType55);
org.joda.time.MutableDateTime.Property property59 = mutableDateTime2.era();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str4, "2020-11-25T01:49:16.264Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str11, "2020-11-25T01:49:16.264Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str15, "2020-11-25T01:49:16.264Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T00:00:00.035Z" + "'", str18, "2020-11-25T00:00:00.035Z");
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str23, "2020-11-25T01:49:16.264Z");
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 20 + "'", int24 == 20);
org.junit.Assert.assertNotNull(chronology25);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str32, "2020-11-25T01:49:16.264Z");
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str39, "2020-11-25T01:49:16.264Z");
org.junit.Assert.assertNotNull(property42);
// flaky: org.junit.Assert.assertEquals("'" + str43 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str43, "2020-11-25T01:49:16.264Z");
org.junit.Assert.assertTrue("'" + int44 + "' != '" + (-1) + "'", int44 == (-1));
org.junit.Assert.assertNotNull(obj45);
org.junit.Assert.assertEquals(obj45.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj45), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj45), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long46 + "' != '" + 1606262400035L + "'", long46 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str51 + "' != '" + "2020-11-25T01:49:16.264Z" + "'", str51, "2020-11-25T01:49:16.264Z");
org.junit.Assert.assertNotNull(property54);
org.junit.Assert.assertNotNull(dateTimeFieldType55);
org.junit.Assert.assertTrue("'" + int56 + "' != '" + 0 + "'", int56 == 0);
org.junit.Assert.assertNotNull(property57);
org.junit.Assert.assertTrue("'" + boolean58 + "' != '" + true + "'", boolean58 == true);
org.junit.Assert.assertNotNull(property59);
}
@Test
@Ignore
public void test1868() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1868");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime13 = property8.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime14 = property8.roundHalfFloor();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime14.monthOfYear();
java.util.Locale locale16 = null;
java.lang.String str17 = property15.getAsText(locale16);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.344Z" + "'", str4, "2020-11-25T01:49:16.344Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(mutableDateTime14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertEquals("'" + str17 + "' != '" + "November" + "'", str17, "November");
}
@Test
@Ignore
public void test1869() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1869");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.DateTimeField dateTimeField4 = property2.getField();
org.joda.time.MutableDateTime mutableDateTime6 = property2.add(1L);
mutableDateTime6.setDayOfYear((int) (short) 100);
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfYear();
int int13 = property12.get();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.centuryOfEra();
org.joda.time.ReadableInstant readableInstant22 = null;
mutableDateTime16.setDate(readableInstant22);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfMonth();
int int26 = mutableDateTime24.getCenturyOfEra();
org.joda.time.Chronology chronology28 = null;
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology28);
mutableDateTime29.setSecondOfMinute((int) '4');
int int32 = mutableDateTime29.getMinuteOfDay();
int int33 = mutableDateTime29.getCenturyOfEra();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
int int37 = mutableDateTime36.getDayOfWeek();
java.lang.Object obj38 = null;
org.joda.time.Chronology chronology39 = null;
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime(obj38, chronology39);
org.joda.time.DateTimeZone dateTimeZone41 = mutableDateTime40.getZone();
org.joda.time.MutableDateTime mutableDateTime42 = org.joda.time.MutableDateTime.now(dateTimeZone41);
mutableDateTime36.setZoneRetainFields(dateTimeZone41);
org.joda.time.DateTime dateTime44 = mutableDateTime29.toDateTime(dateTimeZone41);
mutableDateTime24.setZoneRetainFields(dateTimeZone41);
mutableDateTime16.setZone(dateTimeZone41);
org.joda.time.MutableDateTime mutableDateTime47 = org.joda.time.MutableDateTime.now(dateTimeZone41);
long long48 = property12.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime47);
org.joda.time.MutableDateTime mutableDateTime49 = property12.roundCeiling();
int int50 = mutableDateTime6.compareTo((org.joda.time.ReadableInstant) mutableDateTime49);
mutableDateTime49.setYear(2);
java.util.GregorianCalendar gregorianCalendar53 = mutableDateTime49.toGregorianCalendar();
mutableDateTime49.setYear(6386);
boolean boolean57 = mutableDateTime49.isAfter((long) 23);
java.lang.Object obj59 = null;
org.joda.time.Chronology chronology60 = null;
org.joda.time.MutableDateTime mutableDateTime61 = new org.joda.time.MutableDateTime(obj59, chronology60);
org.joda.time.format.DateTimeFormatter dateTimeFormatter62 = null;
java.lang.String str63 = mutableDateTime61.toString(dateTimeFormatter62);
org.joda.time.ReadablePeriod readablePeriod64 = null;
mutableDateTime61.add(readablePeriod64);
org.joda.time.MutableDateTime.Property property66 = mutableDateTime61.hourOfDay();
org.joda.time.MutableDateTime.Property property67 = mutableDateTime61.dayOfWeek();
int int68 = property67.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime70 = property67.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime71 = property67.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod72 = null;
mutableDateTime71.add(readablePeriod72, 40);
java.lang.Object obj75 = null;
org.joda.time.Chronology chronology76 = null;
org.joda.time.MutableDateTime mutableDateTime77 = new org.joda.time.MutableDateTime(obj75, chronology76);
org.joda.time.format.DateTimeFormatter dateTimeFormatter78 = null;
java.lang.String str79 = mutableDateTime77.toString(dateTimeFormatter78);
int int80 = mutableDateTime77.getYearOfCentury();
org.joda.time.Chronology chronology81 = mutableDateTime77.getChronology();
org.joda.time.MutableDateTime mutableDateTime82 = mutableDateTime71.toMutableDateTime(chronology81);
org.joda.time.MutableDateTime mutableDateTime83 = new org.joda.time.MutableDateTime(6436228L, chronology81);
org.joda.time.MutableDateTime mutableDateTime84 = mutableDateTime49.toMutableDateTime(chronology81);
// The following exception was thrown during execution in test generation
try {
mutableDateTime84.setDayOfYear(6531);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6531 for dayOfYear must be in the range [1,365]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField4);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 1 + "'", int13 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:16.381Z" + "'", str18, "2020-11-25T01:49:16.381Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 0 + "'", int32 == 0);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 19 + "'", int33 == 19);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 3 + "'", int37 == 3);
org.junit.Assert.assertNotNull(dateTimeZone41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime44);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertTrue("'" + long48 + "' != '" + (-18591L) + "'", long48 == (-18591L));
org.junit.Assert.assertNotNull(mutableDateTime49);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 1 + "'", int50 == 1);
org.junit.Assert.assertNotNull(gregorianCalendar53);
org.junit.Assert.assertTrue("'" + boolean57 + "' != '" + true + "'", boolean57 == true);
// flaky: org.junit.Assert.assertEquals("'" + str63 + "' != '" + "2020-11-25T01:49:16.381Z" + "'", str63, "2020-11-25T01:49:16.381Z");
org.junit.Assert.assertNotNull(property66);
org.junit.Assert.assertNotNull(property67);
org.junit.Assert.assertTrue("'" + int68 + "' != '" + 7 + "'", int68 == 7);
org.junit.Assert.assertNotNull(mutableDateTime70);
org.junit.Assert.assertNotNull(mutableDateTime71);
// flaky: org.junit.Assert.assertEquals("'" + str79 + "' != '" + "2020-11-25T01:49:16.381Z" + "'", str79, "2020-11-25T01:49:16.381Z");
org.junit.Assert.assertTrue("'" + int80 + "' != '" + 20 + "'", int80 == 20);
org.junit.Assert.assertNotNull(chronology81);
org.junit.Assert.assertNotNull(mutableDateTime82);
org.junit.Assert.assertNotNull(mutableDateTime84);
}
@Test
@Ignore
public void test1870() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1870");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
int int10 = mutableDateTime2.getWeekOfWeekyear();
mutableDateTime2.addYears((-1));
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime2.add(readablePeriod13);
org.joda.time.MutableDateTime mutableDateTime15 = mutableDateTime2.toMutableDateTimeISO();
int int16 = mutableDateTime15.getYearOfCentury();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
int int20 = mutableDateTime19.getDayOfWeek();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.DateTimeZone dateTimeZone24 = mutableDateTime23.getZone();
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(dateTimeZone24);
mutableDateTime19.setZoneRetainFields(dateTimeZone24);
mutableDateTime15.setZone(dateTimeZone24);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.438Z" + "'", str4, "2020-11-25T01:49:16.438Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 48 + "'", int10 == 48);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 19 + "'", int16 == 19);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 3 + "'", int20 == 3);
org.junit.Assert.assertNotNull(dateTimeZone24);
org.junit.Assert.assertNotNull(mutableDateTime25);
}
@Test
public void test1871() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1871");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.secondOfMinute();
int int8 = property7.getMaximumValueOverall();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 59 + "'", int8 == 59);
}
@Test
@Ignore
public void test1872() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1872");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
int int5 = mutableDateTime2.getMinuteOfDay();
mutableDateTime2.setDate((long) 6300);
boolean boolean9 = mutableDateTime2.isBefore((long) (byte) 0);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime2.add(readablePeriod10, (int) (short) 0);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime2.dayOfWeek();
int int14 = property13.getMaximumValue();
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 0 + "'", int5 == 0);
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 7 + "'", int14 == 7);
}
@Test
@Ignore
public void test1873() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1873");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime13 = property11.add((long) (short) -1);
mutableDateTime13.setWeekOfWeekyear((int) '4');
mutableDateTime7.setTime((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.secondOfDay();
mutableDateTime13.setMillisOfDay((int) (byte) 1);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime13.weekyear();
mutableDateTime13.setWeekyear(18591);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime13.minuteOfDay();
org.joda.time.MutableDateTime.Property property24 = mutableDateTime13.secondOfMinute();
mutableDateTime13.addWeekyears(2025);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.564Z" + "'", str4, "2020-11-25T01:49:16.564Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertNotNull(property24);
}
@Test
@Ignore
public void test1874() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1874");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
mutableDateTime3.setMinuteOfDay(4);
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
int int12 = mutableDateTime9.getYearOfCentury();
org.joda.time.Chronology chronology13 = mutableDateTime9.getChronology();
int int14 = mutableDateTime9.getWeekOfWeekyear();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.DateTime dateTime19 = mutableDateTime9.toDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime3.toMutableDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone18);
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.format.DateTimeFormatter dateTimeFormatter25 = null;
java.lang.String str26 = mutableDateTime24.toString(dateTimeFormatter25);
org.joda.time.ReadablePeriod readablePeriod27 = null;
mutableDateTime24.add(readablePeriod27);
org.joda.time.MutableDateTime.Property property29 = mutableDateTime24.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType30 = property29.getFieldType();
boolean boolean31 = mutableDateTime21.isSupported(dateTimeFieldType30);
org.joda.time.MutableDateTime.Property property32 = mutableDateTime21.minuteOfDay();
org.joda.time.MutableDateTime.Property property33 = mutableDateTime21.era();
org.junit.Assert.assertNotNull(dateTimeZone4);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:16.677Z" + "'", str11, "2020-11-25T01:49:16.677Z");
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 20 + "'", int12 == 20);
org.junit.Assert.assertNotNull(chronology13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 48 + "'", int14 == 48);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(dateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:16.677Z" + "'", str26, "2020-11-25T01:49:16.677Z");
org.junit.Assert.assertNotNull(property29);
org.junit.Assert.assertNotNull(dateTimeFieldType30);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + true + "'", boolean31 == true);
org.junit.Assert.assertNotNull(property32);
org.junit.Assert.assertNotNull(property33);
}
@Test
public void test1875() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1875");
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.yearOfCentury();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.centuryOfEra();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.DateTimeZone dateTimeZone21 = mutableDateTime20.getZone();
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone21);
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone21);
mutableDateTime23.setSecondOfMinute((int) (short) 0);
org.joda.time.ReadableDuration readableDuration26 = null;
mutableDateTime23.add(readableDuration26);
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property29 = mutableDateTime28.dayOfMonth();
boolean boolean31 = mutableDateTime28.isBefore((long) 9);
org.joda.time.Chronology chronology32 = mutableDateTime28.getChronology();
org.joda.time.MutableDateTime mutableDateTime33 = org.joda.time.MutableDateTime.now(chronology32);
mutableDateTime23.setChronology(chronology32);
mutableDateTime9.setChronology(chronology32);
org.joda.time.MutableDateTime mutableDateTime36 = org.joda.time.MutableDateTime.now(chronology32);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(0, 1970, 627, 896, 0, 1439, 39, chronology32);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 896 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:16.711Z" + "'", str11, "2020-11-25T01:49:16.711Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(dateTimeZone21);
org.junit.Assert.assertNotNull(property29);
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertNotNull(chronology32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(mutableDateTime36);
}
@Test
public void test1876() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1876");
org.joda.time.format.DateTimeFormatter dateTimeFormatter1 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime2 = org.joda.time.MutableDateTime.parse("2020-11-25T01:49:01.718Z", dateTimeFormatter1);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1877() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1877");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
java.lang.Object obj6 = null;
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime(obj6, chronology7);
org.joda.time.format.DateTimeFormatter dateTimeFormatter9 = null;
java.lang.String str10 = mutableDateTime8.toString(dateTimeFormatter9);
org.joda.time.ReadablePeriod readablePeriod11 = null;
mutableDateTime8.add(readablePeriod11);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime8.hourOfDay();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime8.dayOfWeek();
int int15 = property14.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime17 = property14.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime18 = property14.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime18.add(readablePeriod19, 40);
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.format.DateTimeFormatter dateTimeFormatter25 = null;
java.lang.String str26 = mutableDateTime24.toString(dateTimeFormatter25);
int int27 = mutableDateTime24.getYearOfCentury();
org.joda.time.Chronology chronology28 = mutableDateTime24.getChronology();
org.joda.time.MutableDateTime mutableDateTime29 = mutableDateTime18.toMutableDateTime(chronology28);
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime((long) 100, chronology28);
org.joda.time.MutableDateTime mutableDateTime31 = org.joda.time.MutableDateTime.now(chronology28);
org.joda.time.MutableDateTime mutableDateTime32 = mutableDateTime2.toMutableDateTime(chronology28);
int int33 = mutableDateTime2.getCenturyOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str10 + "' != '" + "2020-11-25T01:49:16.753Z" + "'", str10, "2020-11-25T01:49:16.753Z");
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 7 + "'", int15 == 7);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(mutableDateTime18);
// flaky: org.junit.Assert.assertEquals("'" + str26 + "' != '" + "2020-11-25T01:49:16.753Z" + "'", str26, "2020-11-25T01:49:16.753Z");
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 20 + "'", int27 == 20);
org.junit.Assert.assertNotNull(chronology28);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime32);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 19 + "'", int33 == 19);
}
@Test
public void test1878() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1878");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((-50L));
org.joda.time.ReadableDuration readableDuration2 = null;
mutableDateTime1.add(readableDuration2, 20);
mutableDateTime1.addMillis((int) (byte) 100);
org.joda.time.DateTime dateTime7 = mutableDateTime1.toDateTimeISO();
mutableDateTime1.addYears(6544);
org.junit.Assert.assertNotNull(dateTime7);
}
@Test
@Ignore
public void test1879() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1879");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime13.add(readablePeriod14, 40);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime13.toMutableDateTime(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 100, chronology23);
org.joda.time.MutableDateTime mutableDateTime26 = new org.joda.time.MutableDateTime(chronology23);
java.lang.Object obj27 = null;
org.joda.time.Chronology chronology28 = null;
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime(obj27, chronology28);
org.joda.time.format.DateTimeFormatter dateTimeFormatter30 = null;
java.lang.String str31 = mutableDateTime29.toString(dateTimeFormatter30);
org.joda.time.ReadablePeriod readablePeriod32 = null;
mutableDateTime29.add(readablePeriod32);
org.joda.time.MutableDateTime.Property property34 = mutableDateTime29.hourOfDay();
java.lang.String str35 = mutableDateTime29.toString();
mutableDateTime29.setSecondOfDay(2);
int int38 = mutableDateTime29.getDayOfWeek();
java.lang.Object obj39 = null;
org.joda.time.Chronology chronology40 = null;
org.joda.time.MutableDateTime mutableDateTime41 = new org.joda.time.MutableDateTime(obj39, chronology40);
org.joda.time.DateTimeZone dateTimeZone42 = mutableDateTime41.getZone();
mutableDateTime41.setMinuteOfDay(4);
java.lang.Object obj45 = null;
org.joda.time.Chronology chronology46 = null;
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime(obj45, chronology46);
org.joda.time.format.DateTimeFormatter dateTimeFormatter48 = null;
java.lang.String str49 = mutableDateTime47.toString(dateTimeFormatter48);
int int50 = mutableDateTime47.getYearOfCentury();
org.joda.time.Chronology chronology51 = mutableDateTime47.getChronology();
int int52 = mutableDateTime47.getWeekOfWeekyear();
java.lang.Object obj53 = null;
org.joda.time.Chronology chronology54 = null;
org.joda.time.MutableDateTime mutableDateTime55 = new org.joda.time.MutableDateTime(obj53, chronology54);
org.joda.time.DateTimeZone dateTimeZone56 = mutableDateTime55.getZone();
org.joda.time.DateTime dateTime57 = mutableDateTime47.toDateTime(dateTimeZone56);
org.joda.time.MutableDateTime mutableDateTime58 = mutableDateTime41.toMutableDateTime(dateTimeZone56);
org.joda.time.MutableDateTime mutableDateTime59 = new org.joda.time.MutableDateTime(dateTimeZone56);
mutableDateTime29.setZoneRetainFields(dateTimeZone56);
org.joda.time.MutableDateTime mutableDateTime61 = new org.joda.time.MutableDateTime(dateTimeZone56);
mutableDateTime26.setZoneRetainFields(dateTimeZone56);
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:16.816Z" + "'", str5, "2020-11-25T01:49:16.816Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:16.817Z" + "'", str21, "2020-11-25T01:49:16.817Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
// flaky: org.junit.Assert.assertEquals("'" + str31 + "' != '" + "2020-11-25T01:49:16.817Z" + "'", str31, "2020-11-25T01:49:16.817Z");
org.junit.Assert.assertNotNull(property34);
// flaky: org.junit.Assert.assertEquals("'" + str35 + "' != '" + "2020-11-25T01:49:16.817Z" + "'", str35, "2020-11-25T01:49:16.817Z");
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 3 + "'", int38 == 3);
org.junit.Assert.assertNotNull(dateTimeZone42);
// flaky: org.junit.Assert.assertEquals("'" + str49 + "' != '" + "2020-11-25T01:49:16.817Z" + "'", str49, "2020-11-25T01:49:16.817Z");
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 20 + "'", int50 == 20);
org.junit.Assert.assertNotNull(chronology51);
org.junit.Assert.assertTrue("'" + int52 + "' != '" + 48 + "'", int52 == 48);
org.junit.Assert.assertNotNull(dateTimeZone56);
org.junit.Assert.assertNotNull(dateTime57);
org.junit.Assert.assertNotNull(mutableDateTime58);
}
@Test
@Ignore
public void test1880() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1880");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
java.lang.Object obj4 = null;
org.joda.time.Chronology chronology5 = null;
org.joda.time.MutableDateTime mutableDateTime6 = new org.joda.time.MutableDateTime(obj4, chronology5);
org.joda.time.format.DateTimeFormatter dateTimeFormatter7 = null;
java.lang.String str8 = mutableDateTime6.toString(dateTimeFormatter7);
mutableDateTime6.setTime((long) '#');
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
org.joda.time.ReadablePeriod readablePeriod16 = null;
mutableDateTime13.add(readablePeriod16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.hourOfDay();
java.lang.String str19 = mutableDateTime13.toString();
int int20 = mutableDateTime6.compareTo((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime mutableDateTime21 = mutableDateTime6.copy();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime6.dayOfYear();
org.joda.time.DateTimeField dateTimeField23 = property22.getField();
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setRounding(dateTimeField23, 107);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal rounding mode: 107");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T01:49:16.900Z" + "'", str8, "2020-11-25T01:49:16.900Z");
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:16.900Z" + "'", str15, "2020-11-25T01:49:16.900Z");
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str19 + "' != '" + "2020-11-25T01:49:16.900Z" + "'", str19, "2020-11-25T01:49:16.900Z");
org.junit.Assert.assertTrue("'" + int20 + "' != '" + (-1) + "'", int20 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertNotNull(dateTimeField23);
}
@Test
@Ignore
public void test1881() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1881");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
org.joda.time.DateTimeField dateTimeField19 = property18.getField();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime21.add(readablePeriod22);
java.util.GregorianCalendar gregorianCalendar24 = mutableDateTime21.toGregorianCalendar();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
int int28 = mutableDateTime27.getDayOfWeek();
mutableDateTime27.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property31 = mutableDateTime27.secondOfMinute();
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology33);
mutableDateTime34.setSecondOfMinute((int) '4');
int int37 = mutableDateTime34.getMinuteOfDay();
org.joda.time.MutableDateTime.Property property38 = mutableDateTime34.dayOfYear();
mutableDateTime34.setDate((long) 693);
int int41 = mutableDateTime27.compareTo((org.joda.time.ReadableInstant) mutableDateTime34);
java.lang.Object obj42 = null;
org.joda.time.Chronology chronology43 = null;
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(obj42, chronology43);
org.joda.time.format.DateTimeFormatter dateTimeFormatter45 = null;
java.lang.String str46 = mutableDateTime44.toString(dateTimeFormatter45);
org.joda.time.ReadablePeriod readablePeriod47 = null;
mutableDateTime44.add(readablePeriod47);
org.joda.time.MutableDateTime.Property property49 = mutableDateTime44.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime50 = mutableDateTime44.toMutableDateTimeISO();
java.lang.Object obj51 = null;
org.joda.time.Chronology chronology52 = null;
org.joda.time.MutableDateTime mutableDateTime53 = new org.joda.time.MutableDateTime(obj51, chronology52);
org.joda.time.format.DateTimeFormatter dateTimeFormatter54 = null;
java.lang.String str55 = mutableDateTime53.toString(dateTimeFormatter54);
org.joda.time.ReadablePeriod readablePeriod56 = null;
mutableDateTime53.add(readablePeriod56);
org.joda.time.MutableDateTime.Property property58 = mutableDateTime53.centuryOfEra();
org.joda.time.DateTimeField dateTimeField59 = property58.getField();
int int60 = mutableDateTime44.get(dateTimeField59);
int int61 = mutableDateTime27.get(dateTimeField59);
int int62 = mutableDateTime21.get(dateTimeField59);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:16.946Z" + "'", str4, "2020-11-25T01:49:16.946Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:16.946Z" + "'", str11, "2020-11-25T01:49:16.946Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:16.946Z" + "'", str15, "2020-11-25T01:49:16.946Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeField19);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(gregorianCalendar24);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 3 + "'", int28 == 3);
org.junit.Assert.assertNotNull(property31);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 0 + "'", int37 == 0);
org.junit.Assert.assertNotNull(property38);
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 1 + "'", int41 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str46 + "' != '" + "2020-11-25T01:49:16.947Z" + "'", str46, "2020-11-25T01:49:16.947Z");
org.junit.Assert.assertNotNull(property49);
org.junit.Assert.assertNotNull(mutableDateTime50);
// flaky: org.junit.Assert.assertEquals("'" + str55 + "' != '" + "2020-11-25T01:49:16.947Z" + "'", str55, "2020-11-25T01:49:16.947Z");
org.junit.Assert.assertNotNull(property58);
org.junit.Assert.assertNotNull(dateTimeField59);
org.junit.Assert.assertTrue("'" + int60 + "' != '" + 20 + "'", int60 == 20);
org.junit.Assert.assertTrue("'" + int61 + "' != '" + 20 + "'", int61 == 20);
org.junit.Assert.assertTrue("'" + int62 + "' != '" + 20 + "'", int62 == 20);
}
@Test
@Ignore
public void test1882() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1882");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.DateTimeField dateTimeField4 = property2.getField();
org.joda.time.MutableDateTime mutableDateTime6 = property2.add(1L);
mutableDateTime6.setDayOfYear((int) (short) 100);
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfYear();
int int13 = property12.get();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.centuryOfEra();
org.joda.time.ReadableInstant readableInstant22 = null;
mutableDateTime16.setDate(readableInstant22);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfMonth();
int int26 = mutableDateTime24.getCenturyOfEra();
org.joda.time.Chronology chronology28 = null;
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology28);
mutableDateTime29.setSecondOfMinute((int) '4');
int int32 = mutableDateTime29.getMinuteOfDay();
int int33 = mutableDateTime29.getCenturyOfEra();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
int int37 = mutableDateTime36.getDayOfWeek();
java.lang.Object obj38 = null;
org.joda.time.Chronology chronology39 = null;
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime(obj38, chronology39);
org.joda.time.DateTimeZone dateTimeZone41 = mutableDateTime40.getZone();
org.joda.time.MutableDateTime mutableDateTime42 = org.joda.time.MutableDateTime.now(dateTimeZone41);
mutableDateTime36.setZoneRetainFields(dateTimeZone41);
org.joda.time.DateTime dateTime44 = mutableDateTime29.toDateTime(dateTimeZone41);
mutableDateTime24.setZoneRetainFields(dateTimeZone41);
mutableDateTime16.setZone(dateTimeZone41);
org.joda.time.MutableDateTime mutableDateTime47 = org.joda.time.MutableDateTime.now(dateTimeZone41);
long long48 = property12.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime47);
org.joda.time.MutableDateTime mutableDateTime49 = property12.roundCeiling();
int int50 = mutableDateTime6.compareTo((org.joda.time.ReadableInstant) mutableDateTime49);
mutableDateTime49.setYear(2);
java.util.GregorianCalendar gregorianCalendar53 = mutableDateTime49.toGregorianCalendar();
int int54 = mutableDateTime49.getYearOfEra();
int int55 = mutableDateTime49.getYearOfEra();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField4);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 1 + "'", int13 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:17.031Z" + "'", str18, "2020-11-25T01:49:17.031Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 0 + "'", int32 == 0);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 19 + "'", int33 == 19);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 3 + "'", int37 == 3);
org.junit.Assert.assertNotNull(dateTimeZone41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime44);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertTrue("'" + long48 + "' != '" + (-18591L) + "'", long48 == (-18591L));
org.junit.Assert.assertNotNull(mutableDateTime49);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 1 + "'", int50 == 1);
org.junit.Assert.assertNotNull(gregorianCalendar53);
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 2 + "'", int54 == 2);
org.junit.Assert.assertTrue("'" + int55 + "' != '" + 2 + "'", int55 == 2);
}
@Test
@Ignore
public void test1883() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1883");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
boolean boolean12 = mutableDateTime11.isBeforeNow();
java.lang.Object obj13 = null;
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime(obj13, chronology14);
int int16 = mutableDateTime15.getDayOfWeek();
mutableDateTime15.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime15.secondOfMinute();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime15.weekyear();
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
int int26 = mutableDateTime23.getYearOfCentury();
org.joda.time.Chronology chronology27 = mutableDateTime23.getChronology();
int int28 = mutableDateTime23.getWeekOfWeekyear();
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.DateTimeZone dateTimeZone32 = mutableDateTime31.getZone();
org.joda.time.DateTime dateTime33 = mutableDateTime23.toDateTime(dateTimeZone32);
org.joda.time.MutableDateTime mutableDateTime34 = mutableDateTime23.copy();
boolean boolean35 = mutableDateTime23.isAfterNow();
org.joda.time.MutableDateTime.Property property36 = mutableDateTime23.centuryOfEra();
int int37 = property20.getDifference((org.joda.time.ReadableInstant) mutableDateTime23);
mutableDateTime23.setSecondOfDay(21);
mutableDateTime23.addHours(104);
mutableDateTime23.addWeekyears(3);
org.joda.time.Chronology chronology44 = mutableDateTime23.getChronology();
mutableDateTime11.setChronology(chronology44);
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime(chronology44);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.094Z" + "'", str4, "2020-11-25T01:49:17.094Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 3 + "'", int16 == 3);
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertNotNull(property20);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:17.094Z" + "'", str25, "2020-11-25T01:49:17.094Z");
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
org.junit.Assert.assertNotNull(chronology27);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 48 + "'", int28 == 48);
org.junit.Assert.assertNotNull(dateTimeZone32);
org.junit.Assert.assertNotNull(dateTime33);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertTrue("'" + boolean35 + "' != '" + false + "'", boolean35 == false);
org.junit.Assert.assertNotNull(property36);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 0 + "'", int37 == 0);
org.junit.Assert.assertNotNull(chronology44);
}
@Test
public void test1884() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1884");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
int int10 = property8.getMaximumValueOverall();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.146Z" + "'", str4, "2020-11-25T01:49:17.146Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
}
@Test
@Ignore
public void test1885() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1885");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
int int15 = mutableDateTime13.getHourOfDay();
org.joda.time.ReadablePeriod readablePeriod16 = null;
mutableDateTime13.add(readablePeriod16);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.secondOfMinute();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.170Z" + "'", str4, "2020-11-25T01:49:17.170Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 1 + "'", int15 == 1);
org.junit.Assert.assertNotNull(property18);
}
@Test
@Ignore
public void test1886() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1886");
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.weekyear();
long long4 = property3.remainder();
org.joda.time.DateTimeField dateTimeField5 = property3.getField();
org.joda.time.MutableDateTime mutableDateTime7 = property3.add(1L);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime7.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime7.copy();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
int int15 = mutableDateTime12.getYearOfCentury();
org.joda.time.Chronology chronology16 = mutableDateTime12.getChronology();
org.joda.time.MutableDateTime mutableDateTime17 = org.joda.time.MutableDateTime.now(chronology16);
org.joda.time.MutableDateTime mutableDateTime18 = org.joda.time.MutableDateTime.now(chronology16);
mutableDateTime9.setChronology(chronology16);
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:47:20.702Z", chronology16);
int int21 = mutableDateTime20.getMinuteOfDay();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertTrue("'" + long4 + "' != '" + 259200010L + "'", long4 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField5);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(mutableDateTime9);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:17.202Z" + "'", str14, "2020-11-25T01:49:17.202Z");
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 20 + "'", int15 == 20);
org.junit.Assert.assertNotNull(chronology16);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 107 + "'", int21 == 107);
}
@Test
public void test1887() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1887");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime2 = property1.getMutableDateTime();
int int3 = mutableDateTime2.getMinuteOfHour();
// The following exception was thrown during execution in test generation
try {
java.lang.String str5 = mutableDateTime2.toString("2020-11-25T01:48:12.794Z");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal pattern component: T");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(mutableDateTime2);
// flaky: org.junit.Assert.assertTrue("'" + int3 + "' != '" + 49 + "'", int3 == 49);
}
@Test
public void test1888() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1888");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.yearOfCentury();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime3.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime11 = property10.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime12 = property10.roundFloor();
mutableDateTime12.addDays(422);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime18.add(readablePeriod21);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime18.yearOfCentury();
int int24 = property23.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime25 = property23.roundFloor();
org.joda.time.DurationField durationField26 = property23.getRangeDurationField();
org.joda.time.MutableDateTime mutableDateTime27 = property23.roundHalfFloor();
org.joda.time.DateTimeZone dateTimeZone28 = mutableDateTime27.getZone();
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime((long) 105, dateTimeZone28);
org.joda.time.DateTime dateTime30 = mutableDateTime12.toDateTime(dateTimeZone28);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((java.lang.Object) 104, dateTimeZone28);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: No instant converter found for type: java.lang.Integer");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:17.263Z" + "'", str5, "2020-11-25T01:49:17.263Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:17.263Z" + "'", str20, "2020-11-25T01:49:17.263Z");
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 0 + "'", int24 == 0);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(durationField26);
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertNotNull(dateTimeZone28);
org.junit.Assert.assertNotNull(dateTime30);
}
@Test
public void test1889() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1889");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime9 = property7.set(49);
boolean boolean10 = mutableDateTime9.isEqualNow();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime9.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime12 = property11.roundHalfEven();
java.util.Locale locale13 = null;
int int14 = property11.getMaximumTextLength(locale13);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime16 = property11.set(48);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 48 for dayOfMonth must be in the range [1,31]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 2 + "'", int14 == 2);
}
@Test
public void test1890() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1890");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime10 = property9.roundCeiling();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.year();
mutableDateTime10.setMinuteOfHour((int) '#');
// The following exception was thrown during execution in test generation
try {
mutableDateTime10.setHourOfDay((-26769600));
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value -26769600 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.354Z" + "'", str4, "2020-11-25T01:49:17.354Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
}
@Test
@Ignore
public void test1891() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1891");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime2.dayOfYear();
org.joda.time.DateTimeField dateTimeField19 = property18.getField();
org.joda.time.MutableDateTime mutableDateTime21 = property18.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime22 = property18.roundFloor();
java.lang.String str23 = property18.getAsString();
long long24 = property18.remainder();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.375Z" + "'", str4, "2020-11-25T01:49:17.375Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:17.375Z" + "'", str11, "2020-11-25T01:49:17.375Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:17.375Z" + "'", str15, "2020-11-25T01:49:17.375Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(dateTimeField19);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertEquals("'" + str23 + "' != '" + "330" + "'", str23, "330");
org.junit.Assert.assertTrue("'" + long24 + "' != '" + 0L + "'", long24 == 0L);
}
@Test
public void test1892() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1892");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
mutableDateTime20.setTime((long) '#');
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.format.DateTimeFormatter dateTimeFormatter28 = null;
java.lang.String str29 = mutableDateTime27.toString(dateTimeFormatter28);
org.joda.time.ReadablePeriod readablePeriod30 = null;
mutableDateTime27.add(readablePeriod30);
org.joda.time.MutableDateTime.Property property32 = mutableDateTime27.hourOfDay();
java.lang.String str33 = mutableDateTime27.toString();
int int34 = mutableDateTime20.compareTo((org.joda.time.ReadableInstant) mutableDateTime27);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime27.millisOfDay();
org.joda.time.Chronology chronology36 = mutableDateTime27.getChronology();
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology36);
org.joda.time.MutableDateTime.Property property38 = mutableDateTime37.minuteOfHour();
org.joda.time.Chronology chronology39 = mutableDateTime37.getChronology();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.403Z" + "'", str4, "2020-11-25T01:49:17.403Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:17.403Z" + "'", str11, "2020-11-25T01:49:17.403Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:17.403Z" + "'", str15, "2020-11-25T01:49:17.403Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:17.403Z" + "'", str22, "2020-11-25T01:49:17.403Z");
// flaky: org.junit.Assert.assertEquals("'" + str29 + "' != '" + "2020-11-25T01:49:17.403Z" + "'", str29, "2020-11-25T01:49:17.403Z");
org.junit.Assert.assertNotNull(property32);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:49:17.403Z" + "'", str33, "2020-11-25T01:49:17.403Z");
org.junit.Assert.assertTrue("'" + int34 + "' != '" + (-1) + "'", int34 == (-1));
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(chronology36);
org.junit.Assert.assertNotNull(property38);
org.junit.Assert.assertNotNull(chronology39);
}
@Test
@Ignore
public void test1893() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1893");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
int int6 = mutableDateTime3.getMinuteOfDay();
int int7 = mutableDateTime3.getCenturyOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
org.joda.time.MutableDateTime mutableDateTime16 = org.joda.time.MutableDateTime.now(dateTimeZone15);
mutableDateTime10.setZoneRetainFields(dateTimeZone15);
org.joda.time.DateTime dateTime18 = mutableDateTime3.toDateTime(dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(259200010L, dateTimeZone15);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime19.dayOfYear();
int int21 = mutableDateTime19.getDayOfWeek();
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime22.dayOfMonth();
int int24 = mutableDateTime22.getCenturyOfEra();
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology26);
mutableDateTime27.setSecondOfMinute((int) '4');
int int30 = mutableDateTime27.getMinuteOfDay();
int int31 = mutableDateTime27.getCenturyOfEra();
java.lang.Object obj32 = null;
org.joda.time.Chronology chronology33 = null;
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime(obj32, chronology33);
int int35 = mutableDateTime34.getDayOfWeek();
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.DateTimeZone dateTimeZone39 = mutableDateTime38.getZone();
org.joda.time.MutableDateTime mutableDateTime40 = org.joda.time.MutableDateTime.now(dateTimeZone39);
mutableDateTime34.setZoneRetainFields(dateTimeZone39);
org.joda.time.DateTime dateTime42 = mutableDateTime27.toDateTime(dateTimeZone39);
mutableDateTime22.setZoneRetainFields(dateTimeZone39);
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime(dateTimeZone39);
org.joda.time.DateTime dateTime45 = mutableDateTime19.toDateTime(dateTimeZone39);
int int46 = mutableDateTime19.getYearOfEra();
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 0 + "'", int6 == 0);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 19 + "'", int7 == 19);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 7 + "'", int21 == 7);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 20 + "'", int24 == 20);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 0 + "'", int30 == 0);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 19 + "'", int31 == 19);
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 3 + "'", int35 == 3);
org.junit.Assert.assertNotNull(dateTimeZone39);
org.junit.Assert.assertNotNull(mutableDateTime40);
org.junit.Assert.assertNotNull(dateTime42);
org.junit.Assert.assertNotNull(dateTime45);
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 1970 + "'", int46 == 1970);
}
@Test
@Ignore
public void test1894() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1894");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
int int9 = mutableDateTime8.getMillisOfDay();
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime8.add(readablePeriod10, 6389);
org.joda.time.DurationFieldType durationFieldType13 = null;
// The following exception was thrown during execution in test generation
try {
mutableDateTime8.add(durationFieldType13, 211);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Field must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int9 + "' != '" + 6557546 + "'", int9 == 6557546);
}
@Test
@Ignore
public void test1895() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1895");
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology2);
mutableDateTime3.setSecondOfMinute((int) '4');
int int6 = mutableDateTime3.getMinuteOfDay();
int int7 = mutableDateTime3.getCenturyOfEra();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
int int11 = mutableDateTime10.getDayOfWeek();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
org.joda.time.MutableDateTime mutableDateTime16 = org.joda.time.MutableDateTime.now(dateTimeZone15);
mutableDateTime10.setZoneRetainFields(dateTimeZone15);
org.joda.time.DateTime dateTime18 = mutableDateTime3.toDateTime(dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((long) 1439, dateTimeZone15);
java.util.Date date20 = mutableDateTime19.toDate();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime19.millisOfSecond();
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 0 + "'", int6 == 0);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 19 + "'", int7 == 19);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3 + "'", int11 == 3);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(date20);
org.junit.Assert.assertEquals(date20.toString(), "Thu Jan 01 00:00:01 UTC 1970");
org.junit.Assert.assertNotNull(property21);
}
@Test
@Ignore
public void test1896() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1896");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.year();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
int int19 = mutableDateTime16.getYearOfCentury();
org.joda.time.Chronology chronology20 = mutableDateTime16.getChronology();
int int21 = mutableDateTime16.getWeekOfWeekyear();
java.lang.Object obj22 = null;
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime(obj22, chronology23);
org.joda.time.DateTimeZone dateTimeZone25 = mutableDateTime24.getZone();
org.joda.time.DateTime dateTime26 = mutableDateTime16.toDateTime(dateTimeZone25);
org.joda.time.MutableDateTime mutableDateTime27 = mutableDateTime16.copy();
org.joda.time.MutableDateTime.Property property28 = mutableDateTime27.dayOfWeek();
mutableDateTime12.setDate((org.joda.time.ReadableInstant) mutableDateTime27);
int int30 = mutableDateTime12.getSecondOfDay();
mutableDateTime12.setWeekOfWeekyear((int) (short) 1);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.628Z" + "'", str4, "2020-11-25T01:49:17.628Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:17.628Z" + "'", str18, "2020-11-25T01:49:17.628Z");
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 20 + "'", int19 == 20);
org.junit.Assert.assertNotNull(chronology20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 48 + "'", int21 == 48);
org.junit.Assert.assertNotNull(dateTimeZone25);
org.junit.Assert.assertNotNull(dateTime26);
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertNotNull(property28);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 0 + "'", int30 == 0);
}
@Test
@Ignore
public void test1897() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1897");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
java.lang.Object obj7 = mutableDateTime5.clone();
mutableDateTime5.setMonthOfYear(3);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime5.year();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime5.monthOfYear();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(obj7);
org.junit.Assert.assertEquals(obj7.toString(), "2020-12-01T00:00:00.000Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj7), "2020-12-01T00:00:00.000Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj7), "2020-12-01T00:00:00.000Z");
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(property11);
}
@Test
@Ignore
public void test1898() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1898");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime5.toMutableDateTime();
mutableDateTime6.setMillis((long) (-1));
int int9 = mutableDateTime6.getDayOfYear();
int int10 = mutableDateTime6.getDayOfYear();
mutableDateTime6.setMinuteOfDay(445);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 365 + "'", int9 == 365);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 365 + "'", int10 == 365);
}
@Test
@Ignore
public void test1899() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1899");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.Date date4 = mutableDateTime2.toDate();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.centuryOfEra();
org.joda.time.MutableDateTime mutableDateTime6 = property5.roundHalfEven();
boolean boolean8 = mutableDateTime6.isBefore((long) 353);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(date4);
org.junit.Assert.assertEquals(date4.toString(), "Thu Jan 01 00:00:00 UTC 1970");
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
}
@Test
public void test1900() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1900");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
org.joda.time.MutableDateTime mutableDateTime10 = property9.roundCeiling();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.year();
java.util.Date date12 = mutableDateTime10.toDate();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.771Z" + "'", str4, "2020-11-25T01:49:17.771Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(date12);
// flaky: org.junit.Assert.assertEquals(date12.toString(), "Wed Nov 25 01:49:17 UTC 2020");
}
@Test
@Ignore
public void test1901() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1901");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.MutableDateTime mutableDateTime8 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.MutableDateTime mutableDateTime9 = org.joda.time.MutableDateTime.now(chronology6);
mutableDateTime9.setWeekOfWeekyear(22);
// The following exception was thrown during execution in test generation
try {
mutableDateTime9.setMillisOfSecond(56871817);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 56871817 for millisOfSecond must be in the range [0,999]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.809Z" + "'", str4, "2020-11-25T01:49:17.809Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime9);
}
@Test
public void test1902() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1902");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
boolean boolean12 = mutableDateTime11.isBeforeNow();
mutableDateTime11.setYear(112);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.830Z" + "'", str4, "2020-11-25T01:49:17.830Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
}
@Test
public void test1903() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1903");
org.joda.time.Chronology chronology7 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime(292278993, 470, 376, 6547, 20, 6547, 4, chronology7);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6547 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
}
@Test
public void test1904() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1904");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
int int2 = mutableDateTime0.getCenturyOfEra();
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.format.DateTimeFormatter dateTimeFormatter6 = null;
java.lang.String str7 = mutableDateTime5.toString(dateTimeFormatter6);
org.joda.time.ReadablePeriod readablePeriod8 = null;
mutableDateTime5.add(readablePeriod8);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime5.hourOfDay();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime5.dayOfWeek();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime5.secondOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType13 = property12.getFieldType();
mutableDateTime0.set(dateTimeFieldType13, 2);
mutableDateTime0.setYear(59630400);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 20 + "'", int2 == 20);
// flaky: org.junit.Assert.assertEquals("'" + str7 + "' != '" + "2020-11-25T01:49:17.887Z" + "'", str7, "2020-11-25T01:49:17.887Z");
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(dateTimeFieldType13);
}
@Test
@Ignore
public void test1905() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1905");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundHalfEven();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.hourOfDay();
org.joda.time.MutableDateTime.Property property17 = mutableDateTime11.dayOfWeek();
int int18 = property17.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime20 = property17.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime21 = property17.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime21.add(readablePeriod22, 40);
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.format.DateTimeFormatter dateTimeFormatter28 = null;
java.lang.String str29 = mutableDateTime27.toString(dateTimeFormatter28);
int int30 = mutableDateTime27.getYearOfCentury();
org.joda.time.Chronology chronology31 = mutableDateTime27.getChronology();
org.joda.time.MutableDateTime mutableDateTime32 = mutableDateTime21.toMutableDateTime(chronology31);
org.joda.time.MutableDateTime mutableDateTime33 = org.joda.time.MutableDateTime.now(chronology31);
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
org.joda.time.format.DateTimeFormatter dateTimeFormatter37 = null;
java.lang.String str38 = mutableDateTime36.toString(dateTimeFormatter37);
org.joda.time.ReadablePeriod readablePeriod39 = null;
mutableDateTime36.add(readablePeriod39);
org.joda.time.MutableDateTime.Property property41 = mutableDateTime36.hourOfDay();
org.joda.time.MutableDateTime.Property property42 = mutableDateTime36.dayOfWeek();
org.joda.time.DurationField durationField43 = property42.getRangeDurationField();
org.joda.time.DurationField durationField44 = property42.getDurationField();
org.joda.time.DateTimeField dateTimeField45 = property42.getField();
mutableDateTime33.setRounding(dateTimeField45);
boolean boolean47 = mutableDateTime8.equals((java.lang.Object) dateTimeField45);
org.joda.time.MutableDateTime.Property property48 = mutableDateTime8.monthOfYear();
java.lang.Object obj49 = null;
org.joda.time.Chronology chronology50 = null;
org.joda.time.MutableDateTime mutableDateTime51 = new org.joda.time.MutableDateTime(obj49, chronology50);
org.joda.time.format.DateTimeFormatter dateTimeFormatter52 = null;
java.lang.String str53 = mutableDateTime51.toString(dateTimeFormatter52);
org.joda.time.ReadablePeriod readablePeriod54 = null;
mutableDateTime51.add(readablePeriod54);
org.joda.time.MutableDateTime.Property property56 = mutableDateTime51.hourOfDay();
org.joda.time.MutableDateTime.Property property57 = mutableDateTime51.dayOfWeek();
int int58 = property57.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime60 = property57.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime61 = property57.roundHalfEven();
org.joda.time.MutableDateTime.Property property62 = mutableDateTime61.year();
java.lang.String str64 = mutableDateTime61.toString("330");
org.joda.time.Chronology chronology65 = mutableDateTime61.getChronology();
org.joda.time.DateTime dateTime66 = mutableDateTime8.toDateTime(chronology65);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:17.920Z" + "'", str4, "2020-11-25T01:49:17.920Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:17.920Z" + "'", str13, "2020-11-25T01:49:17.920Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 7 + "'", int18 == 7);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertNotNull(mutableDateTime21);
// flaky: org.junit.Assert.assertEquals("'" + str29 + "' != '" + "2020-11-25T01:49:17.921Z" + "'", str29, "2020-11-25T01:49:17.921Z");
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 20 + "'", int30 == 20);
org.junit.Assert.assertNotNull(chronology31);
org.junit.Assert.assertNotNull(mutableDateTime32);
org.junit.Assert.assertNotNull(mutableDateTime33);
// flaky: org.junit.Assert.assertEquals("'" + str38 + "' != '" + "2020-11-25T01:49:17.921Z" + "'", str38, "2020-11-25T01:49:17.921Z");
org.junit.Assert.assertNotNull(property41);
org.junit.Assert.assertNotNull(property42);
org.junit.Assert.assertNotNull(durationField43);
org.junit.Assert.assertNotNull(durationField44);
org.junit.Assert.assertNotNull(dateTimeField45);
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
org.junit.Assert.assertNotNull(property48);
// flaky: org.junit.Assert.assertEquals("'" + str53 + "' != '" + "2020-11-25T01:49:17.921Z" + "'", str53, "2020-11-25T01:49:17.921Z");
org.junit.Assert.assertNotNull(property56);
org.junit.Assert.assertNotNull(property57);
org.junit.Assert.assertTrue("'" + int58 + "' != '" + 7 + "'", int58 == 7);
org.junit.Assert.assertNotNull(mutableDateTime60);
org.junit.Assert.assertNotNull(mutableDateTime61);
org.junit.Assert.assertNotNull(property62);
org.junit.Assert.assertEquals("'" + str64 + "' != '" + "330" + "'", str64, "330");
org.junit.Assert.assertNotNull(chronology65);
org.junit.Assert.assertNotNull(dateTime66);
}
@Test
@Ignore
public void test1906() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1906");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime10 = property8.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
int int12 = mutableDateTime10.getSecondOfDay();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime10.dayOfYear();
java.lang.String str14 = property13.getAsText();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.014Z" + "'", str4, "2020-11-25T01:49:18.014Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertEquals("'" + str14 + "' != '" + "330" + "'", str14, "330");
}
@Test
@Ignore
public void test1907() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1907");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
mutableDateTime13.addDays(2189);
int int17 = mutableDateTime13.getSecondOfMinute();
int int18 = mutableDateTime13.getMinuteOfHour();
mutableDateTime13.add((long) 916);
org.joda.time.DateTimeZone dateTimeZone21 = mutableDateTime13.getZone();
// The following exception was thrown during execution in test generation
try {
mutableDateTime13.setDayOfMonth(222);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 222 for dayOfMonth must be in the range [1,30]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.051Z" + "'", str4, "2020-11-25T01:49:18.051Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
// flaky: org.junit.Assert.assertTrue("'" + int17 + "' != '" + 18 + "'", int17 == 18);
// flaky: org.junit.Assert.assertTrue("'" + int18 + "' != '" + 49 + "'", int18 == 49);
org.junit.Assert.assertNotNull(dateTimeZone21);
}
@Test
@Ignore
public void test1908() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1908");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.secondOfDay();
int int10 = property9.getMaximumValueOverall();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
int int16 = mutableDateTime13.getYearOfCentury();
org.joda.time.Chronology chronology17 = mutableDateTime13.getChronology();
org.joda.time.MutableDateTime mutableDateTime18 = org.joda.time.MutableDateTime.now(chronology17);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(chronology17);
int int20 = property9.compareTo((org.joda.time.ReadableInstant) mutableDateTime19);
java.util.Locale locale22 = null;
// The following exception was thrown during execution in test generation
try {
java.lang.String str23 = mutableDateTime19.toString("", locale22);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Invalid pattern specification");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.093Z" + "'", str4, "2020-11-25T01:49:18.093Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 86399 + "'", int10 == 86399);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:18.093Z" + "'", str15, "2020-11-25T01:49:18.093Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 20 + "'", int16 == 20);
org.junit.Assert.assertNotNull(chronology17);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 0 + "'", int20 == 0);
}
@Test
public void test1909() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1909");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
java.lang.String str7 = mutableDateTime2.toString();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
// flaky: org.junit.Assert.assertEquals("'" + str7 + "' != '" + "2021-03-05T01:49:18.185Z" + "'", str7, "2021-03-05T01:49:18.185Z");
}
@Test
@Ignore
public void test1910() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1910");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime2.toMutableDateTime();
mutableDateTime2.setWeekyear(53);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime2.dayOfYear();
java.lang.Object obj13 = null;
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime(obj13, chronology14);
org.joda.time.format.DateTimeFormatter dateTimeFormatter16 = null;
java.lang.String str17 = mutableDateTime15.toString(dateTimeFormatter16);
mutableDateTime15.setTime((long) '#');
java.lang.Object obj20 = null;
org.joda.time.Chronology chronology21 = null;
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(obj20, chronology21);
org.joda.time.format.DateTimeFormatter dateTimeFormatter23 = null;
java.lang.String str24 = mutableDateTime22.toString(dateTimeFormatter23);
org.joda.time.ReadablePeriod readablePeriod25 = null;
mutableDateTime22.add(readablePeriod25);
org.joda.time.MutableDateTime.Property property27 = mutableDateTime22.hourOfDay();
java.lang.String str28 = mutableDateTime22.toString();
int int29 = mutableDateTime15.compareTo((org.joda.time.ReadableInstant) mutableDateTime22);
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime15.copy();
long long31 = mutableDateTime30.getMillis();
int int32 = mutableDateTime30.getSecondOfMinute();
boolean boolean33 = mutableDateTime30.isAfterNow();
org.joda.time.MutableDateTime.Property property34 = mutableDateTime30.centuryOfEra();
org.joda.time.ReadableDuration readableDuration35 = null;
mutableDateTime30.add(readableDuration35);
int int37 = property12.getDifference((org.joda.time.ReadableInstant) mutableDateTime30);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property12);
// flaky: org.junit.Assert.assertEquals("'" + str17 + "' != '" + "2020-11-25T01:49:18.209Z" + "'", str17, "2020-11-25T01:49:18.209Z");
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:18.209Z" + "'", str24, "2020-11-25T01:49:18.209Z");
org.junit.Assert.assertNotNull(property27);
// flaky: org.junit.Assert.assertEquals("'" + str28 + "' != '" + "2020-11-25T01:49:18.209Z" + "'", str28, "2020-11-25T01:49:18.209Z");
org.junit.Assert.assertTrue("'" + int29 + "' != '" + (-1) + "'", int29 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + long31 + "' != '" + 1606262400035L + "'", long31 == 1606262400035L);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 0 + "'", int32 == 0);
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
org.junit.Assert.assertNotNull(property34);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + (-718728) + "'", int37 == (-718728));
}
@Test
@Ignore
public void test1911() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1911");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
org.joda.time.Chronology chronology24 = mutableDateTime20.getChronology();
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(chronology24);
org.joda.time.MutableDateTime mutableDateTime26 = mutableDateTime2.toMutableDateTime(chronology24);
mutableDateTime26.setMinuteOfDay(14);
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property31 = mutableDateTime30.dayOfMonth();
boolean boolean33 = mutableDateTime30.isBefore((long) 9);
org.joda.time.Chronology chronology34 = mutableDateTime30.getChronology();
org.joda.time.MutableDateTime mutableDateTime35 = org.joda.time.MutableDateTime.now(chronology34);
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(6335532L, chronology34);
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
org.joda.time.format.DateTimeFormatter dateTimeFormatter40 = null;
java.lang.String str41 = mutableDateTime39.toString(dateTimeFormatter40);
org.joda.time.ReadablePeriod readablePeriod42 = null;
mutableDateTime39.add(readablePeriod42);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime39.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType45 = property44.getFieldType();
boolean boolean46 = mutableDateTime36.isSupported(dateTimeFieldType45);
org.joda.time.MutableDateTime.Property property47 = mutableDateTime26.property(dateTimeFieldType45);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.284Z" + "'", str4, "2020-11-25T01:49:18.284Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:18.284Z" + "'", str11, "2020-11-25T01:49:18.284Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:18.284Z" + "'", str15, "2020-11-25T01:49:18.284Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:18.284Z" + "'", str22, "2020-11-25T01:49:18.284Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(chronology24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(property31);
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
org.junit.Assert.assertNotNull(chronology34);
org.junit.Assert.assertNotNull(mutableDateTime35);
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:18.284Z" + "'", str41, "2020-11-25T01:49:18.284Z");
org.junit.Assert.assertNotNull(property44);
org.junit.Assert.assertNotNull(dateTimeFieldType45);
org.junit.Assert.assertTrue("'" + boolean46 + "' != '" + true + "'", boolean46 == true);
org.junit.Assert.assertNotNull(property47);
}
@Test
@Ignore
public void test1912() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1912");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
int int9 = property8.getLeapAmount();
org.joda.time.DurationField durationField10 = property8.getLeapDurationField();
org.joda.time.MutableDateTime mutableDateTime11 = property8.roundCeiling();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
org.junit.Assert.assertNull(durationField10);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
@Test
public void test1913() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1913");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.ReadableInstant readableInstant8 = null;
mutableDateTime2.setDate(readableInstant8);
mutableDateTime2.setMillis((long) 'a');
int int12 = mutableDateTime2.getEra();
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setSecondOfMinute(6414);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6414 for secondOfMinute must be in the range [0,59]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.486Z" + "'", str4, "2020-11-25T01:49:18.486Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1 + "'", int12 == 1);
}
@Test
@Ignore
public void test1914() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1914");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime13.dayOfWeek();
int int15 = property14.getMinimumValueOverall();
org.joda.time.MutableDateTime mutableDateTime16 = property14.roundFloor();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime19.add(readablePeriod22);
org.joda.time.MutableDateTime.Property property24 = mutableDateTime19.hourOfDay();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime19.dayOfWeek();
int int26 = property25.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime28 = property25.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime29 = property25.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime30 = property25.roundHalfFloor();
mutableDateTime30.addMinutes(40);
int int33 = property14.compareTo((org.joda.time.ReadableInstant) mutableDateTime30);
org.joda.time.ReadableInstant readableInstant34 = null;
long long35 = property14.getDifferenceAsLong(readableInstant34);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.522Z" + "'", str4, "2020-11-25T01:49:18.522Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 1 + "'", int15 == 1);
org.junit.Assert.assertNotNull(mutableDateTime16);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:18.522Z" + "'", str21, "2020-11-25T01:49:18.522Z");
org.junit.Assert.assertNotNull(property24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 7 + "'", int26 == 7);
org.junit.Assert.assertNotNull(mutableDateTime28);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 0 + "'", int33 == 0);
org.junit.Assert.assertTrue("'" + long35 + "' != '" + 0L + "'", long35 == 0L);
}
@Test
@Ignore
public void test1915() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1915");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
java.util.GregorianCalendar gregorianCalendar6 = mutableDateTime5.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime5.millisOfDay();
org.joda.time.Chronology chronology8 = mutableDateTime5.getChronology();
int int9 = mutableDateTime5.getYearOfEra();
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology11);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime15 = property13.add((long) (short) -1);
java.util.Locale locale16 = null;
int int17 = property13.getMaximumShortTextLength(locale16);
long long18 = property13.remainder();
org.joda.time.DateTimeField dateTimeField19 = property13.getField();
mutableDateTime5.setRounding(dateTimeField19);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(gregorianCalendar6);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(chronology8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 2020 + "'", int9 == 2020);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(mutableDateTime15);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 3 + "'", int17 == 3);
org.junit.Assert.assertTrue("'" + long18 + "' != '" + 1L + "'", long18 == 1L);
org.junit.Assert.assertNotNull(dateTimeField19);
}
@Test
@Ignore
public void test1916() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1916");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
int int7 = property6.getMaximumValue();
org.joda.time.Interval interval8 = property6.toInterval();
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 59 + "'", int7 == 59);
org.junit.Assert.assertNotNull(interval8);
}
@Test
@Ignore
public void test1917() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1917");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
int int4 = mutableDateTime2.getSecondOfMinute();
int int5 = mutableDateTime2.getMonthOfYear();
int int6 = mutableDateTime2.getMillisOfSecond();
mutableDateTime2.setMillisOfDay(56871817);
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 18 + "'", int4 == 18);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 11 + "'", int5 == 11);
// flaky: org.junit.Assert.assertTrue("'" + int6 + "' != '" + 655 + "'", int6 == 655);
}
@Test
public void test1918() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1918");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
int int16 = mutableDateTime12.getCenturyOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.714Z" + "'", str4, "2020-11-25T01:49:18.714Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 20 + "'", int16 == 20);
}
@Test
public void test1919() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1919");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime10 = property7.add((long) 5);
org.joda.time.DateTimeField dateTimeField11 = property7.getField();
java.util.Locale locale12 = null;
int int13 = property7.getMaximumShortTextLength(locale12);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.739Z" + "'", str4, "2020-11-25T01:49:18.739Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertNotNull(dateTimeField11);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 2 + "'", int13 == 2);
}
@Test
public void test1920() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1920");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DateTimeFieldType dateTimeFieldType9 = property8.getFieldType();
org.joda.time.MutableDateTime mutableDateTime11 = property8.add(6542);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.794Z" + "'", str4, "2020-11-25T01:49:18.794Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(dateTimeFieldType9);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
@Test
@Ignore
public void test1921() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1921");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime2.minuteOfDay();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime2.minuteOfDay();
boolean boolean15 = mutableDateTime2.isEqualNow();
boolean boolean17 = mutableDateTime2.isBefore((long) 99);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.825Z" + "'", str4, "2020-11-25T01:49:18.825Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
}
@Test
@Ignore
public void test1922() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1922");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
int int4 = mutableDateTime2.getSecondOfMinute();
int int5 = mutableDateTime2.getMonthOfYear();
int int6 = mutableDateTime2.getMillisOfSecond();
int int7 = mutableDateTime2.getMinuteOfHour();
org.joda.time.DateTime dateTime8 = mutableDateTime2.toDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime9 = mutableDateTime2.toMutableDateTimeISO();
// The following exception was thrown during execution in test generation
try {
mutableDateTime2.setHourOfDay(6494370);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6494370 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 18 + "'", int4 == 18);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 11 + "'", int5 == 11);
// flaky: org.junit.Assert.assertTrue("'" + int6 + "' != '" + 855 + "'", int6 == 855);
// flaky: org.junit.Assert.assertTrue("'" + int7 + "' != '" + 49 + "'", int7 == 49);
org.junit.Assert.assertNotNull(dateTime8);
org.junit.Assert.assertNotNull(mutableDateTime9);
}
@Test
public void test1923() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1923");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
java.lang.String str8 = mutableDateTime2.toString();
boolean boolean9 = mutableDateTime2.isEqualNow();
org.joda.time.ReadableDuration readableDuration10 = null;
mutableDateTime2.add(readableDuration10);
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.format.DateTimeFormatter dateTimeFormatter15 = null;
java.lang.String str16 = mutableDateTime14.toString(dateTimeFormatter15);
mutableDateTime14.setTime((long) '#');
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.hourOfDay();
java.lang.String str27 = mutableDateTime21.toString();
int int28 = mutableDateTime14.compareTo((org.joda.time.ReadableInstant) mutableDateTime21);
org.joda.time.MutableDateTime mutableDateTime29 = mutableDateTime14.copy();
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
mutableDateTime32.setTime((long) '#');
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
org.joda.time.format.DateTimeFormatter dateTimeFormatter40 = null;
java.lang.String str41 = mutableDateTime39.toString(dateTimeFormatter40);
org.joda.time.ReadablePeriod readablePeriod42 = null;
mutableDateTime39.add(readablePeriod42);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime39.hourOfDay();
java.lang.String str45 = mutableDateTime39.toString();
int int46 = mutableDateTime32.compareTo((org.joda.time.ReadableInstant) mutableDateTime39);
org.joda.time.MutableDateTime.Property property47 = mutableDateTime39.millisOfDay();
org.joda.time.Chronology chronology48 = mutableDateTime39.getChronology();
org.joda.time.MutableDateTime mutableDateTime49 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime14, chronology48);
org.joda.time.MutableDateTime.Property property50 = mutableDateTime49.minuteOfHour();
boolean boolean51 = mutableDateTime2.isAfter((org.joda.time.ReadableInstant) mutableDateTime49);
org.joda.time.MutableDateTime.Property property52 = mutableDateTime2.yearOfEra();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str4, "2020-11-25T01:49:18.882Z");
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str8 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str8, "2020-11-25T01:49:18.882Z");
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + true + "'", boolean9 == true);
// flaky: org.junit.Assert.assertEquals("'" + str16 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str16, "2020-11-25T01:49:18.882Z");
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str23, "2020-11-25T01:49:18.882Z");
org.junit.Assert.assertNotNull(property26);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str27, "2020-11-25T01:49:18.882Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + (-1) + "'", int28 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime29);
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str34, "2020-11-25T01:49:18.882Z");
// flaky: org.junit.Assert.assertEquals("'" + str41 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str41, "2020-11-25T01:49:18.882Z");
org.junit.Assert.assertNotNull(property44);
// flaky: org.junit.Assert.assertEquals("'" + str45 + "' != '" + "2020-11-25T01:49:18.882Z" + "'", str45, "2020-11-25T01:49:18.882Z");
org.junit.Assert.assertTrue("'" + int46 + "' != '" + (-1) + "'", int46 == (-1));
org.junit.Assert.assertNotNull(property47);
org.junit.Assert.assertNotNull(chronology48);
org.junit.Assert.assertNotNull(property50);
org.junit.Assert.assertTrue("'" + boolean51 + "' != '" + true + "'", boolean51 == true);
org.junit.Assert.assertNotNull(property52);
}
@Test
public void test1924() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1924");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
mutableDateTime0.setTime((long) 10);
java.util.Locale locale6 = null;
// The following exception was thrown during execution in test generation
try {
java.lang.String str7 = mutableDateTime0.toString("2020-11-25T01:49:12.519Z", locale6);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal pattern component: T");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
}
@Test
@Ignore
public void test1925() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1925");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
org.joda.time.DateTimeZone dateTimeZone7 = mutableDateTime2.getZone();
mutableDateTime2.setMinuteOfHour((int) '4');
mutableDateTime2.addYears(56);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(dateTimeZone7);
}
@Test
@Ignore
public void test1926() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1926");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
boolean boolean24 = mutableDateTime23.isBeforeNow();
int int25 = mutableDateTime23.getWeekOfWeekyear();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime23.dayOfMonth();
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = mutableDateTime23.toMutableDateTime(chronology27);
mutableDateTime28.addDays(26);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:18.968Z" + "'", str4, "2020-11-25T01:49:18.968Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:18.968Z" + "'", str20, "2020-11-25T01:49:18.968Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + true + "'", boolean24 == true);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 48 + "'", int25 == 48);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(mutableDateTime28);
}
@Test
@Ignore
public void test1927() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1927");
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime31 = org.joda.time.MutableDateTime.now(chronology29);
org.joda.time.MutableDateTime mutableDateTime32 = org.joda.time.MutableDateTime.now(chronology29);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime(635, 6330255, 173, 106, 56942393, 40, 0, chronology29);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 106 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:19.004Z" + "'", str11, "2020-11-25T01:49:19.004Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:19.004Z" + "'", str27, "2020-11-25T01:49:19.004Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime31);
org.junit.Assert.assertNotNull(mutableDateTime32);
}
@Test
public void test1928() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1928");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.MutableDateTime mutableDateTime6 = mutableDateTime2.toMutableDateTime();
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime2.add(readablePeriod7);
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(mutableDateTime6);
}
@Test
public void test1929() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1929");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.DateTimeField dateTimeField8 = property7.getField();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
java.util.Locale locale10 = null;
int int11 = property7.getMaximumShortTextLength(locale10);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:19.058Z" + "'", str4, "2020-11-25T01:49:19.058Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(dateTimeField8);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 7 + "'", int11 == 7);
}
@Test
public void test1930() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1930");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
java.lang.String str10 = property8.getName();
org.joda.time.MutableDateTime mutableDateTime11 = property8.roundCeiling();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.format.DateTimeFormatter dateTimeFormatter15 = null;
java.lang.String str16 = mutableDateTime14.toString(dateTimeFormatter15);
org.joda.time.ReadablePeriod readablePeriod17 = null;
mutableDateTime14.add(readablePeriod17);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime14.yearOfCentury();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime14.dayOfWeek();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime14.millisOfDay();
org.joda.time.ReadablePeriod readablePeriod22 = null;
mutableDateTime14.add(readablePeriod22);
int int24 = property8.getDifference((org.joda.time.ReadableInstant) mutableDateTime14);
boolean boolean25 = property8.isLeap();
org.joda.time.DurationField durationField26 = property8.getDurationField();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:19.080Z" + "'", str4, "2020-11-25T01:49:19.080Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertEquals("'" + str10 + "' != '" + "dayOfWeek" + "'", str10, "dayOfWeek");
org.junit.Assert.assertNotNull(mutableDateTime11);
// flaky: org.junit.Assert.assertEquals("'" + str16 + "' != '" + "2020-11-25T01:49:19.080Z" + "'", str16, "2020-11-25T01:49:19.080Z");
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 0 + "'", int24 == 0);
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
org.junit.Assert.assertNotNull(durationField26);
}
@Test
public void test1931() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1931");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.millisOfSecond();
java.util.Locale locale7 = null;
// The following exception was thrown during execution in test generation
try {
java.lang.String str8 = mutableDateTime2.toString("2020-11-25T01:47:54.297Z", locale7);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal pattern component: T");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(property5);
}
@Test
@Ignore
public void test1932() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1932");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
int int4 = property3.get();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.format.DateTimeFormatter dateTimeFormatter8 = null;
java.lang.String str9 = mutableDateTime7.toString(dateTimeFormatter8);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime7.add(readablePeriod10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime7.centuryOfEra();
org.joda.time.ReadableInstant readableInstant13 = null;
mutableDateTime7.setDate(readableInstant13);
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime15.dayOfMonth();
int int17 = mutableDateTime15.getCenturyOfEra();
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology19);
mutableDateTime20.setSecondOfMinute((int) '4');
int int23 = mutableDateTime20.getMinuteOfDay();
int int24 = mutableDateTime20.getCenturyOfEra();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
int int28 = mutableDateTime27.getDayOfWeek();
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.DateTimeZone dateTimeZone32 = mutableDateTime31.getZone();
org.joda.time.MutableDateTime mutableDateTime33 = org.joda.time.MutableDateTime.now(dateTimeZone32);
mutableDateTime27.setZoneRetainFields(dateTimeZone32);
org.joda.time.DateTime dateTime35 = mutableDateTime20.toDateTime(dateTimeZone32);
mutableDateTime15.setZoneRetainFields(dateTimeZone32);
mutableDateTime7.setZone(dateTimeZone32);
org.joda.time.MutableDateTime mutableDateTime38 = org.joda.time.MutableDateTime.now(dateTimeZone32);
long long39 = property3.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime38);
org.joda.time.MutableDateTime mutableDateTime40 = property3.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime41 = property3.getMutableDateTime();
org.joda.time.MutableDateTime mutableDateTime43 = property3.addWrapField(6291);
org.joda.time.MutableDateTime.Property property44 = mutableDateTime43.millisOfDay();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:19.189Z" + "'", str9, "2020-11-25T01:49:19.189Z");
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 20 + "'", int17 == 20);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 0 + "'", int23 == 0);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 19 + "'", int24 == 19);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 3 + "'", int28 == 3);
org.junit.Assert.assertNotNull(dateTimeZone32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(dateTime35);
org.junit.Assert.assertNotNull(mutableDateTime38);
org.junit.Assert.assertTrue("'" + long39 + "' != '" + (-18591L) + "'", long39 == (-18591L));
org.junit.Assert.assertNotNull(mutableDateTime40);
org.junit.Assert.assertNotNull(mutableDateTime41);
org.junit.Assert.assertNotNull(mutableDateTime43);
org.junit.Assert.assertNotNull(property44);
}
@Test
public void test1933() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1933");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.millisOfDay();
mutableDateTime2.add((long) 3);
mutableDateTime2.addWeekyears((int) (byte) 100);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime2.weekOfWeekyear();
org.joda.time.DateTime dateTime15 = mutableDateTime2.toDateTime();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime2.dayOfWeek();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:19.242Z" + "'", str4, "2020-11-25T01:49:19.242Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(dateTime15);
org.junit.Assert.assertNotNull(property16);
}
@Test
@Ignore
public void test1934() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1934");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
org.joda.time.Chronology chronology24 = mutableDateTime20.getChronology();
int int25 = mutableDateTime20.getWeekOfWeekyear();
java.lang.Object obj26 = null;
org.joda.time.Chronology chronology27 = null;
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(obj26, chronology27);
org.joda.time.DateTimeZone dateTimeZone29 = mutableDateTime28.getZone();
org.joda.time.DateTime dateTime30 = mutableDateTime20.toDateTime(dateTimeZone29);
org.joda.time.DateTimeZone dateTimeZone31 = mutableDateTime20.getZone();
mutableDateTime17.setZoneRetainFields(dateTimeZone31);
// The following exception was thrown during execution in test generation
try {
java.lang.String str34 = mutableDateTime17.toString("2020-11-25T01:47:09.540Z");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal pattern component: T");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:19.274Z" + "'", str4, "2020-11-25T01:49:19.274Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:19.274Z" + "'", str11, "2020-11-25T01:49:19.274Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:19.274Z" + "'", str15, "2020-11-25T01:49:19.274Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:19.274Z" + "'", str22, "2020-11-25T01:49:19.274Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(chronology24);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 48 + "'", int25 == 48);
org.junit.Assert.assertNotNull(dateTimeZone29);
org.junit.Assert.assertNotNull(dateTime30);
org.junit.Assert.assertNotNull(dateTimeZone31);
}
@Test
@Ignore
public void test1935() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1935");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
org.joda.time.ReadableInstant readableInstant17 = null;
mutableDateTime11.setDate(readableInstant17);
java.util.Date date19 = mutableDateTime11.toDate();
mutableDateTime11.setWeekyear(10);
mutableDateTime11.add((long) 70);
mutableDateTime2.setDate((org.joda.time.ReadableInstant) mutableDateTime11);
int int25 = mutableDateTime11.getHourOfDay();
int int26 = mutableDateTime11.getMonthOfYear();
int int27 = mutableDateTime11.getDayOfYear();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
mutableDateTime30.setTime((long) '#');
java.lang.Object obj35 = null;
org.joda.time.Chronology chronology36 = null;
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime(obj35, chronology36);
org.joda.time.format.DateTimeFormatter dateTimeFormatter38 = null;
java.lang.String str39 = mutableDateTime37.toString(dateTimeFormatter38);
org.joda.time.ReadablePeriod readablePeriod40 = null;
mutableDateTime37.add(readablePeriod40);
org.joda.time.MutableDateTime.Property property42 = mutableDateTime37.hourOfDay();
java.lang.String str43 = mutableDateTime37.toString();
int int44 = mutableDateTime30.compareTo((org.joda.time.ReadableInstant) mutableDateTime37);
java.lang.Object obj45 = mutableDateTime30.clone();
long long46 = mutableDateTime30.getMillis();
org.joda.time.MutableDateTime mutableDateTime47 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime30);
int int48 = mutableDateTime47.getWeekOfWeekyear();
int int49 = mutableDateTime47.getMinuteOfHour();
mutableDateTime11.setDate((org.joda.time.ReadableInstant) mutableDateTime47);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:19.322Z" + "'", str13, "2020-11-25T01:49:19.322Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(date19);
// flaky: org.junit.Assert.assertEquals(date19.toString(), "Wed Nov 25 01:49:19 UTC 2020");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 1 + "'", int25 == 1);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 12 + "'", int26 == 12);
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 335 + "'", int27 == 335);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:19.322Z" + "'", str32, "2020-11-25T01:49:19.322Z");
// flaky: org.junit.Assert.assertEquals("'" + str39 + "' != '" + "2020-11-25T01:49:19.322Z" + "'", str39, "2020-11-25T01:49:19.322Z");
org.junit.Assert.assertNotNull(property42);
// flaky: org.junit.Assert.assertEquals("'" + str43 + "' != '" + "2020-11-25T01:49:19.322Z" + "'", str43, "2020-11-25T01:49:19.322Z");
org.junit.Assert.assertTrue("'" + int44 + "' != '" + (-1) + "'", int44 == (-1));
org.junit.Assert.assertNotNull(obj45);
org.junit.Assert.assertEquals(obj45.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj45), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj45), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long46 + "' != '" + 1606262400035L + "'", long46 == 1606262400035L);
org.junit.Assert.assertTrue("'" + int48 + "' != '" + 48 + "'", int48 == 48);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 0 + "'", int49 == 0);
}
@Test
@Ignore
public void test1936() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1936");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
mutableDateTime2.setMinuteOfDay(4);
java.lang.Object obj6 = null;
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime(obj6, chronology7);
org.joda.time.format.DateTimeFormatter dateTimeFormatter9 = null;
java.lang.String str10 = mutableDateTime8.toString(dateTimeFormatter9);
int int11 = mutableDateTime8.getYearOfCentury();
org.joda.time.Chronology chronology12 = mutableDateTime8.getChronology();
int int13 = mutableDateTime8.getWeekOfWeekyear();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.DateTimeZone dateTimeZone17 = mutableDateTime16.getZone();
org.joda.time.DateTime dateTime18 = mutableDateTime8.toDateTime(dateTimeZone17);
org.joda.time.MutableDateTime mutableDateTime19 = mutableDateTime2.toMutableDateTime(dateTimeZone17);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime19.hourOfDay();
mutableDateTime19.addWeekyears((int) '#');
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertEquals("'" + str10 + "' != '" + "2020-11-25T01:49:19.369Z" + "'", str10, "2020-11-25T01:49:19.369Z");
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 20 + "'", int11 == 20);
org.junit.Assert.assertNotNull(chronology12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 48 + "'", int13 == 48);
org.junit.Assert.assertNotNull(dateTimeZone17);
org.junit.Assert.assertNotNull(dateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertNotNull(property20);
}
@Test
@Ignore
public void test1937() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1937");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.millisOfSecond();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfHour();
org.joda.time.Chronology chronology7 = null;
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology7);
org.joda.time.MutableDateTime.Property property9 = mutableDateTime8.dayOfYear();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.DateTimeZone dateTimeZone14 = mutableDateTime13.getZone();
mutableDateTime13.setMinuteOfDay(4);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
int int24 = mutableDateTime19.getWeekOfWeekyear();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.DateTimeZone dateTimeZone28 = mutableDateTime27.getZone();
org.joda.time.DateTime dateTime29 = mutableDateTime19.toDateTime(dateTimeZone28);
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime13.toMutableDateTime(dateTimeZone28);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone28);
org.joda.time.MutableDateTime mutableDateTime32 = mutableDateTime8.toMutableDateTime(dateTimeZone28);
mutableDateTime8.setMinuteOfDay(9);
boolean boolean35 = mutableDateTime8.isAfterNow();
int int36 = property5.getDifference((org.joda.time.ReadableInstant) mutableDateTime8);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertNotNull(dateTimeZone14);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:19.408Z" + "'", str21, "2020-11-25T01:49:19.408Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 48 + "'", int24 == 48);
org.junit.Assert.assertNotNull(dateTimeZone28);
org.junit.Assert.assertNotNull(dateTime29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime32);
org.junit.Assert.assertTrue("'" + boolean35 + "' != '" + false + "'", boolean35 == false);
org.junit.Assert.assertTrue("'" + int36 + "' != '" + (-9) + "'", int36 == (-9));
}
@Test
@Ignore
public void test1938() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1938");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
java.lang.Object obj3 = null;
org.joda.time.Chronology chronology4 = null;
org.joda.time.MutableDateTime mutableDateTime5 = new org.joda.time.MutableDateTime(obj3, chronology4);
org.joda.time.format.DateTimeFormatter dateTimeFormatter6 = null;
java.lang.String str7 = mutableDateTime5.toString(dateTimeFormatter6);
org.joda.time.ReadablePeriod readablePeriod8 = null;
mutableDateTime5.add(readablePeriod8);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime5.centuryOfEra();
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
int int16 = mutableDateTime13.getYearOfCentury();
org.joda.time.Chronology chronology17 = mutableDateTime13.getChronology();
org.joda.time.MutableDateTime mutableDateTime18 = mutableDateTime5.toMutableDateTime(chronology17);
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology17);
org.joda.time.MutableDateTime mutableDateTime20 = org.joda.time.MutableDateTime.now(chronology17);
org.joda.time.MutableDateTime mutableDateTime21 = org.joda.time.MutableDateTime.now(chronology17);
org.joda.time.MutableDateTime mutableDateTime22 = new org.joda.time.MutableDateTime(chronology17);
// flaky: org.junit.Assert.assertEquals("'" + str7 + "' != '" + "2020-11-25T01:49:19.461Z" + "'", str7, "2020-11-25T01:49:19.461Z");
org.junit.Assert.assertNotNull(property10);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:19.461Z" + "'", str15, "2020-11-25T01:49:19.461Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 20 + "'", int16 == 20);
org.junit.Assert.assertNotNull(chronology17);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime20);
org.junit.Assert.assertNotNull(mutableDateTime21);
}
@Test
@Ignore
public void test1939() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1939");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.DateTimeZone dateTimeZone8 = mutableDateTime7.getZone();
mutableDateTime7.setMinuteOfDay(4);
java.lang.Object obj11 = null;
org.joda.time.Chronology chronology12 = null;
org.joda.time.MutableDateTime mutableDateTime13 = new org.joda.time.MutableDateTime(obj11, chronology12);
org.joda.time.format.DateTimeFormatter dateTimeFormatter14 = null;
java.lang.String str15 = mutableDateTime13.toString(dateTimeFormatter14);
int int16 = mutableDateTime13.getYearOfCentury();
org.joda.time.Chronology chronology17 = mutableDateTime13.getChronology();
int int18 = mutableDateTime13.getWeekOfWeekyear();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.DateTimeZone dateTimeZone22 = mutableDateTime21.getZone();
org.joda.time.DateTime dateTime23 = mutableDateTime13.toDateTime(dateTimeZone22);
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime7.toMutableDateTime(dateTimeZone22);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone22);
org.joda.time.MutableDateTime mutableDateTime26 = mutableDateTime2.toMutableDateTime(dateTimeZone22);
org.joda.time.MutableDateTime.Property property27 = mutableDateTime26.year();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(dateTimeZone8);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:19.534Z" + "'", str15, "2020-11-25T01:49:19.534Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 20 + "'", int16 == 20);
org.junit.Assert.assertNotNull(chronology17);
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 48 + "'", int18 == 48);
org.junit.Assert.assertNotNull(dateTimeZone22);
org.junit.Assert.assertNotNull(dateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(property27);
}
@Test
@Ignore
public void test1940() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1940");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime2.year();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:19.581Z" + "'", str4, "2020-11-25T01:49:19.581Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property14);
}
@Test
@Ignore
public void test1941() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1941");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime mutableDateTime8 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime11.add(readablePeriod14);
org.joda.time.MutableDateTime.Property property16 = mutableDateTime11.centuryOfEra();
org.joda.time.ReadableInstant readableInstant17 = null;
mutableDateTime11.setDate(readableInstant17);
java.util.Date date19 = mutableDateTime11.toDate();
mutableDateTime11.setWeekyear(10);
mutableDateTime11.add((long) 70);
mutableDateTime2.setDate((org.joda.time.ReadableInstant) mutableDateTime11);
int int25 = mutableDateTime11.getHourOfDay();
int int26 = mutableDateTime11.getMonthOfYear();
java.util.Locale locale27 = null;
java.util.Calendar calendar28 = mutableDateTime11.toCalendar(locale27);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:19.641Z" + "'", str13, "2020-11-25T01:49:19.641Z");
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(date19);
// flaky: org.junit.Assert.assertEquals(date19.toString(), "Wed Nov 25 01:49:19 UTC 2020");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 1 + "'", int25 == 1);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 12 + "'", int26 == 12);
org.junit.Assert.assertNotNull(calendar28);
// flaky: org.junit.Assert.assertEquals(calendar28.toString(), "java.util.GregorianCalendar[time=-61822735840289,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=10,MONTH=11,WEEK_OF_YEAR=49,WEEK_OF_MONTH=1,DAY_OF_MONTH=3,DAY_OF_YEAR=337,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=1,HOUR_OF_DAY=1,MINUTE=49,SECOND=19,MILLISECOND=711,ZONE_OFFSET=0,DST_OFFSET=0]");
}
@Test
@Ignore
public void test1942() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1942");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.Date date14 = mutableDateTime13.toDate();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:19.666Z" + "'", str4, "2020-11-25T01:49:19.666Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(date14);
// flaky: org.junit.Assert.assertEquals(date14.toString(), "Wed Nov 25 01:49:19 UTC 2020");
}
@Test
@Ignore
public void test1943() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1943");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.secondOfMinute();
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.weekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
int int13 = mutableDateTime10.getYearOfCentury();
org.joda.time.Chronology chronology14 = mutableDateTime10.getChronology();
int int15 = mutableDateTime10.getWeekOfWeekyear();
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.DateTimeZone dateTimeZone19 = mutableDateTime18.getZone();
org.joda.time.DateTime dateTime20 = mutableDateTime10.toDateTime(dateTimeZone19);
org.joda.time.MutableDateTime mutableDateTime21 = mutableDateTime10.copy();
boolean boolean22 = mutableDateTime10.isAfterNow();
org.joda.time.MutableDateTime.Property property23 = mutableDateTime10.centuryOfEra();
int int24 = property7.getDifference((org.joda.time.ReadableInstant) mutableDateTime10);
mutableDateTime10.setSecondOfDay(21);
mutableDateTime10.addHours(104);
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.format.DateTimeFormatter dateTimeFormatter32 = null;
java.lang.String str33 = mutableDateTime31.toString(dateTimeFormatter32);
org.joda.time.ReadablePeriod readablePeriod34 = null;
mutableDateTime31.add(readablePeriod34);
org.joda.time.MutableDateTime.Property property36 = mutableDateTime31.centuryOfEra();
org.joda.time.ReadableInstant readableInstant37 = null;
mutableDateTime31.setDate(readableInstant37);
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property40 = mutableDateTime39.dayOfMonth();
int int41 = mutableDateTime39.getCenturyOfEra();
org.joda.time.Chronology chronology43 = null;
org.joda.time.MutableDateTime mutableDateTime44 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology43);
mutableDateTime44.setSecondOfMinute((int) '4');
int int47 = mutableDateTime44.getMinuteOfDay();
int int48 = mutableDateTime44.getCenturyOfEra();
java.lang.Object obj49 = null;
org.joda.time.Chronology chronology50 = null;
org.joda.time.MutableDateTime mutableDateTime51 = new org.joda.time.MutableDateTime(obj49, chronology50);
int int52 = mutableDateTime51.getDayOfWeek();
java.lang.Object obj53 = null;
org.joda.time.Chronology chronology54 = null;
org.joda.time.MutableDateTime mutableDateTime55 = new org.joda.time.MutableDateTime(obj53, chronology54);
org.joda.time.DateTimeZone dateTimeZone56 = mutableDateTime55.getZone();
org.joda.time.MutableDateTime mutableDateTime57 = org.joda.time.MutableDateTime.now(dateTimeZone56);
mutableDateTime51.setZoneRetainFields(dateTimeZone56);
org.joda.time.DateTime dateTime59 = mutableDateTime44.toDateTime(dateTimeZone56);
mutableDateTime39.setZoneRetainFields(dateTimeZone56);
mutableDateTime31.setZone(dateTimeZone56);
org.joda.time.MutableDateTime mutableDateTime62 = org.joda.time.MutableDateTime.now(dateTimeZone56);
mutableDateTime10.setZoneRetainFields(dateTimeZone56);
mutableDateTime10.addYears(466);
org.joda.time.ReadableDuration readableDuration66 = null;
mutableDateTime10.add(readableDuration66, 493);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(property7);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:19.730Z" + "'", str12, "2020-11-25T01:49:19.730Z");
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 20 + "'", int13 == 20);
org.junit.Assert.assertNotNull(chronology14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 48 + "'", int15 == 48);
org.junit.Assert.assertNotNull(dateTimeZone19);
org.junit.Assert.assertNotNull(dateTime20);
org.junit.Assert.assertNotNull(mutableDateTime21);
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
org.junit.Assert.assertNotNull(property23);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 0 + "'", int24 == 0);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:49:19.730Z" + "'", str33, "2020-11-25T01:49:19.730Z");
org.junit.Assert.assertNotNull(property36);
org.junit.Assert.assertNotNull(property40);
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 20 + "'", int41 == 20);
org.junit.Assert.assertTrue("'" + int47 + "' != '" + 0 + "'", int47 == 0);
org.junit.Assert.assertTrue("'" + int48 + "' != '" + 19 + "'", int48 == 19);
org.junit.Assert.assertTrue("'" + int52 + "' != '" + 3 + "'", int52 == 3);
org.junit.Assert.assertNotNull(dateTimeZone56);
org.junit.Assert.assertNotNull(mutableDateTime57);
org.junit.Assert.assertNotNull(dateTime59);
org.junit.Assert.assertNotNull(mutableDateTime62);
}
@Test
public void test1944() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1944");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
int int2 = mutableDateTime0.getCenturyOfEra();
mutableDateTime0.addSeconds(409);
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 20 + "'", int2 == 20);
}
@Test
@Ignore
public void test1945() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1945");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property3.add((long) (short) -1);
java.util.Locale locale6 = null;
int int7 = property3.getMaximumShortTextLength(locale6);
long long8 = property3.remainder();
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.Instant instant12 = mutableDateTime11.toInstant();
mutableDateTime11.setSecondOfDay((int) '#');
mutableDateTime11.setTime((int) (short) 10, (int) '#', 49, (int) (byte) 10);
int int20 = mutableDateTime11.getMillisOfSecond();
int int21 = property3.compareTo((org.joda.time.ReadableInstant) mutableDateTime11);
org.joda.time.MutableDateTime mutableDateTime22 = property3.roundCeiling();
mutableDateTime22.setTime((long) 6464264);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 3 + "'", int7 == 3);
org.junit.Assert.assertTrue("'" + long8 + "' != '" + 1L + "'", long8 == 1L);
org.junit.Assert.assertNotNull(instant12);
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 10 + "'", int20 == 10);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 1 + "'", int21 == 1);
org.junit.Assert.assertNotNull(mutableDateTime22);
}
@Test
public void test1946() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1946");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime2.minuteOfHour();
int int10 = property9.getMaximumValueOverall();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:19.854Z" + "'", str4, "2020-11-25T01:49:19.854Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 59 + "'", int10 == 59);
}
@Test
@Ignore
public void test1947() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1947");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
java.util.GregorianCalendar gregorianCalendar6 = mutableDateTime2.toGregorianCalendar();
boolean boolean7 = mutableDateTime2.isBeforeNow();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.format.DateTimeFormatter dateTimeFormatter11 = null;
java.lang.String str12 = mutableDateTime10.toString(dateTimeFormatter11);
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime10.add(readablePeriod13);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime10.hourOfDay();
org.joda.time.MutableDateTime.Property property16 = mutableDateTime10.dayOfWeek();
org.joda.time.MutableDateTime.Property property17 = mutableDateTime10.secondOfDay();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime20.toString(dateTimeFormatter21);
int int23 = mutableDateTime20.getYearOfCentury();
mutableDateTime20.setMillisOfSecond(7);
java.util.Locale locale26 = null;
java.util.Calendar calendar27 = mutableDateTime20.toCalendar(locale26);
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.Instant instant31 = mutableDateTime30.toInstant();
org.joda.time.MutableDateTime.Property property32 = mutableDateTime30.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime33 = property32.roundHalfFloor();
org.joda.time.MutableDateTime mutableDateTime34 = mutableDateTime33.toMutableDateTime();
org.joda.time.MutableDateTime.Property property35 = mutableDateTime33.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime37 = property35.set(49);
org.joda.time.DurationField durationField38 = property35.getDurationField();
org.joda.time.DateTimeField dateTimeField39 = property35.getField();
int int40 = mutableDateTime20.get(dateTimeField39);
mutableDateTime10.setRounding(dateTimeField39);
int int42 = mutableDateTime2.get(dateTimeField39);
org.joda.time.MutableDateTime.Property property43 = mutableDateTime2.minuteOfDay();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(gregorianCalendar6);
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// flaky: org.junit.Assert.assertEquals("'" + str12 + "' != '" + "2020-11-25T01:49:19.880Z" + "'", str12, "2020-11-25T01:49:19.880Z");
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(property16);
org.junit.Assert.assertNotNull(property17);
// flaky: org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-11-25T01:49:19.880Z" + "'", str22, "2020-11-25T01:49:19.880Z");
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 20 + "'", int23 == 20);
org.junit.Assert.assertNotNull(calendar27);
// flaky: org.junit.Assert.assertEquals(calendar27.toString(), "java.util.GregorianCalendar[time=1606268959007,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=java.util.SimpleTimeZone[id=Etc/UTC,offset=0,dstSavings=3600000,useDaylight=false,startYear=0,startMode=0,startMonth=0,startDay=0,startDayOfWeek=0,startTime=0,startTimeMode=0,endMode=0,endMonth=0,endDay=0,endDayOfWeek=0,endTime=0,endTimeMode=0],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=10,WEEK_OF_YEAR=48,WEEK_OF_MONTH=4,DAY_OF_MONTH=25,DAY_OF_YEAR=330,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=1,HOUR_OF_DAY=1,MINUTE=49,SECOND=19,MILLISECOND=7,ZONE_OFFSET=0,DST_OFFSET=0]");
org.junit.Assert.assertNotNull(instant31);
org.junit.Assert.assertNotNull(property32);
org.junit.Assert.assertNotNull(mutableDateTime33);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(mutableDateTime37);
org.junit.Assert.assertNotNull(durationField38);
org.junit.Assert.assertNotNull(dateTimeField39);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 20 + "'", int40 == 20);
org.junit.Assert.assertTrue("'" + int42 + "' != '" + 20 + "'", int42 == 20);
org.junit.Assert.assertNotNull(property43);
}
@Test
@Ignore
public void test1948() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1948");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
java.lang.String str4 = property2.getName();
java.util.Locale locale5 = null;
int int6 = property2.getMaximumShortTextLength(locale5);
org.joda.time.Interval interval7 = property2.toInterval();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "weekyear" + "'", str4, "weekyear");
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 9 + "'", int6 == 9);
org.junit.Assert.assertNotNull(interval7);
}
@Test
public void test1949() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1949");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
org.joda.time.ReadableDuration readableDuration3 = null;
mutableDateTime1.add(readableDuration3, 6417070);
org.joda.time.ReadableInstant readableInstant6 = null;
mutableDateTime1.setMillis(readableInstant6);
org.junit.Assert.assertNotNull(property2);
}
@Test
public void test1950() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1950");
org.joda.time.format.DateTimeFormatter dateTimeFormatter1 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime2 = org.joda.time.MutableDateTime.parse("2020-11-25T01:45:58.090Z", dateTimeFormatter1);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
}
@Test
@Ignore
public void test1951() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1951");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime13 = property11.add((long) (short) -1);
mutableDateTime13.setWeekOfWeekyear((int) '4');
mutableDateTime7.setTime((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.secondOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.secondOfMinute();
boolean boolean20 = mutableDateTime13.isBefore((long) (short) 10);
java.lang.Object obj21 = null;
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime(obj21, chronology22);
org.joda.time.format.DateTimeFormatter dateTimeFormatter24 = null;
java.lang.String str25 = mutableDateTime23.toString(dateTimeFormatter24);
mutableDateTime23.setTime((long) '#');
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
java.lang.String str36 = mutableDateTime30.toString();
int int37 = mutableDateTime23.compareTo((org.joda.time.ReadableInstant) mutableDateTime30);
org.joda.time.MutableDateTime mutableDateTime38 = mutableDateTime23.copy();
java.lang.Object obj39 = null;
org.joda.time.Chronology chronology40 = null;
org.joda.time.MutableDateTime mutableDateTime41 = new org.joda.time.MutableDateTime(obj39, chronology40);
org.joda.time.format.DateTimeFormatter dateTimeFormatter42 = null;
java.lang.String str43 = mutableDateTime41.toString(dateTimeFormatter42);
int int44 = mutableDateTime41.getYearOfCentury();
org.joda.time.Chronology chronology45 = mutableDateTime41.getChronology();
org.joda.time.MutableDateTime mutableDateTime46 = org.joda.time.MutableDateTime.now(chronology45);
org.joda.time.MutableDateTime mutableDateTime47 = mutableDateTime23.toMutableDateTime(chronology45);
java.lang.Object obj48 = null;
org.joda.time.Chronology chronology49 = null;
org.joda.time.MutableDateTime mutableDateTime50 = new org.joda.time.MutableDateTime(obj48, chronology49);
org.joda.time.format.DateTimeFormatter dateTimeFormatter51 = null;
java.lang.String str52 = mutableDateTime50.toString(dateTimeFormatter51);
mutableDateTime50.setTime((long) '#');
java.lang.Object obj55 = null;
org.joda.time.Chronology chronology56 = null;
org.joda.time.MutableDateTime mutableDateTime57 = new org.joda.time.MutableDateTime(obj55, chronology56);
org.joda.time.format.DateTimeFormatter dateTimeFormatter58 = null;
java.lang.String str59 = mutableDateTime57.toString(dateTimeFormatter58);
org.joda.time.ReadablePeriod readablePeriod60 = null;
mutableDateTime57.add(readablePeriod60);
org.joda.time.MutableDateTime.Property property62 = mutableDateTime57.hourOfDay();
java.lang.String str63 = mutableDateTime57.toString();
int int64 = mutableDateTime50.compareTo((org.joda.time.ReadableInstant) mutableDateTime57);
org.joda.time.MutableDateTime mutableDateTime65 = mutableDateTime50.copy();
java.lang.Object obj66 = null;
org.joda.time.Chronology chronology67 = null;
org.joda.time.MutableDateTime mutableDateTime68 = new org.joda.time.MutableDateTime(obj66, chronology67);
org.joda.time.format.DateTimeFormatter dateTimeFormatter69 = null;
java.lang.String str70 = mutableDateTime68.toString(dateTimeFormatter69);
int int71 = mutableDateTime68.getYearOfCentury();
org.joda.time.Chronology chronology72 = mutableDateTime68.getChronology();
org.joda.time.MutableDateTime mutableDateTime73 = org.joda.time.MutableDateTime.now(chronology72);
org.joda.time.MutableDateTime mutableDateTime74 = mutableDateTime50.toMutableDateTime(chronology72);
org.joda.time.DateTime dateTime75 = mutableDateTime23.toDateTime(chronology72);
org.joda.time.DateTime dateTime76 = mutableDateTime13.toDateTime(chronology72);
java.lang.Object obj77 = null;
org.joda.time.Chronology chronology78 = null;
org.joda.time.MutableDateTime mutableDateTime79 = new org.joda.time.MutableDateTime(obj77, chronology78);
org.joda.time.format.DateTimeFormatter dateTimeFormatter80 = null;
java.lang.String str81 = mutableDateTime79.toString(dateTimeFormatter80);
org.joda.time.ReadablePeriod readablePeriod82 = null;
mutableDateTime79.add(readablePeriod82);
org.joda.time.MutableDateTime.Property property84 = mutableDateTime79.hourOfDay();
org.joda.time.MutableDateTime.Property property85 = mutableDateTime79.dayOfWeek();
int int86 = property85.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime87 = property85.roundHalfCeiling();
org.joda.time.MutableDateTime mutableDateTime88 = property85.roundCeiling();
boolean boolean89 = dateTime76.isAfter((org.joda.time.ReadableInstant) mutableDateTime88);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str4, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// flaky: org.junit.Assert.assertEquals("'" + str25 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str25, "2020-11-25T01:49:20.058Z");
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str32, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertNotNull(property35);
// flaky: org.junit.Assert.assertEquals("'" + str36 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str36, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertTrue("'" + int37 + "' != '" + (-1) + "'", int37 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime38);
// flaky: org.junit.Assert.assertEquals("'" + str43 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str43, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 20 + "'", int44 == 20);
org.junit.Assert.assertNotNull(chronology45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertNotNull(mutableDateTime47);
// flaky: org.junit.Assert.assertEquals("'" + str52 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str52, "2020-11-25T01:49:20.058Z");
// flaky: org.junit.Assert.assertEquals("'" + str59 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str59, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertNotNull(property62);
// flaky: org.junit.Assert.assertEquals("'" + str63 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str63, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertTrue("'" + int64 + "' != '" + (-1) + "'", int64 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime65);
// flaky: org.junit.Assert.assertEquals("'" + str70 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str70, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertTrue("'" + int71 + "' != '" + 20 + "'", int71 == 20);
org.junit.Assert.assertNotNull(chronology72);
org.junit.Assert.assertNotNull(mutableDateTime73);
org.junit.Assert.assertNotNull(mutableDateTime74);
org.junit.Assert.assertNotNull(dateTime75);
org.junit.Assert.assertNotNull(dateTime76);
// flaky: org.junit.Assert.assertEquals("'" + str81 + "' != '" + "2020-11-25T01:49:20.058Z" + "'", str81, "2020-11-25T01:49:20.058Z");
org.junit.Assert.assertNotNull(property84);
org.junit.Assert.assertNotNull(property85);
org.junit.Assert.assertTrue("'" + int86 + "' != '" + 7 + "'", int86 == 7);
org.junit.Assert.assertNotNull(mutableDateTime87);
org.junit.Assert.assertNotNull(mutableDateTime88);
org.junit.Assert.assertTrue("'" + boolean89 + "' != '" + false + "'", boolean89 == false);
}
@Test
@Ignore
public void test1952() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1952");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
java.util.GregorianCalendar gregorianCalendar14 = mutableDateTime13.toGregorianCalendar();
mutableDateTime13.setWeekOfWeekyear(20);
mutableDateTime13.setMinuteOfDay(25);
mutableDateTime13.addYears((int) (short) -1);
org.joda.time.Chronology chronology22 = null;
org.joda.time.MutableDateTime mutableDateTime23 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology22);
mutableDateTime23.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property26 = mutableDateTime23.minuteOfDay();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime23.year();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
org.joda.time.MutableDateTime.Property property36 = mutableDateTime30.dayOfWeek();
int int37 = property36.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime39 = property36.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime40 = property36.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod41 = null;
mutableDateTime40.add(readablePeriod41, 40);
java.lang.Object obj44 = null;
org.joda.time.Chronology chronology45 = null;
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime(obj44, chronology45);
org.joda.time.format.DateTimeFormatter dateTimeFormatter47 = null;
java.lang.String str48 = mutableDateTime46.toString(dateTimeFormatter47);
int int49 = mutableDateTime46.getYearOfCentury();
org.joda.time.Chronology chronology50 = mutableDateTime46.getChronology();
org.joda.time.MutableDateTime mutableDateTime51 = mutableDateTime40.toMutableDateTime(chronology50);
mutableDateTime23.setChronology(chronology50);
java.lang.Object obj53 = mutableDateTime23.clone();
org.joda.time.MutableDateTime mutableDateTime54 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property55 = mutableDateTime54.dayOfMonth();
int int56 = mutableDateTime54.getCenturyOfEra();
org.joda.time.Chronology chronology58 = null;
org.joda.time.MutableDateTime mutableDateTime59 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology58);
mutableDateTime59.setSecondOfMinute((int) '4');
int int62 = mutableDateTime59.getMinuteOfDay();
int int63 = mutableDateTime59.getCenturyOfEra();
java.lang.Object obj64 = null;
org.joda.time.Chronology chronology65 = null;
org.joda.time.MutableDateTime mutableDateTime66 = new org.joda.time.MutableDateTime(obj64, chronology65);
int int67 = mutableDateTime66.getDayOfWeek();
java.lang.Object obj68 = null;
org.joda.time.Chronology chronology69 = null;
org.joda.time.MutableDateTime mutableDateTime70 = new org.joda.time.MutableDateTime(obj68, chronology69);
org.joda.time.DateTimeZone dateTimeZone71 = mutableDateTime70.getZone();
org.joda.time.MutableDateTime mutableDateTime72 = org.joda.time.MutableDateTime.now(dateTimeZone71);
mutableDateTime66.setZoneRetainFields(dateTimeZone71);
org.joda.time.DateTime dateTime74 = mutableDateTime59.toDateTime(dateTimeZone71);
mutableDateTime54.setZoneRetainFields(dateTimeZone71);
org.joda.time.MutableDateTime mutableDateTime76 = new org.joda.time.MutableDateTime(dateTimeZone71);
org.joda.time.DateTime dateTime77 = mutableDateTime23.toDateTime(dateTimeZone71);
boolean boolean78 = mutableDateTime13.isBefore((org.joda.time.ReadableInstant) mutableDateTime23);
org.joda.time.MutableDateTime mutableDateTime79 = new org.joda.time.MutableDateTime();
int int80 = mutableDateTime79.getEra();
org.joda.time.Chronology chronology82 = null;
org.joda.time.MutableDateTime mutableDateTime83 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology82);
mutableDateTime83.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property86 = mutableDateTime83.minuteOfDay();
org.joda.time.MutableDateTime.Property property87 = mutableDateTime83.year();
mutableDateTime83.setMillisOfSecond(14);
boolean boolean90 = mutableDateTime79.isBefore((org.joda.time.ReadableInstant) mutableDateTime83);
mutableDateTime13.setDate((org.joda.time.ReadableInstant) mutableDateTime79);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.186Z" + "'", str4, "2020-11-25T01:49:20.186Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(gregorianCalendar14);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:20.186Z" + "'", str32, "2020-11-25T01:49:20.186Z");
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(property36);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 7 + "'", int37 == 7);
org.junit.Assert.assertNotNull(mutableDateTime39);
org.junit.Assert.assertNotNull(mutableDateTime40);
// flaky: org.junit.Assert.assertEquals("'" + str48 + "' != '" + "2020-11-25T01:49:20.186Z" + "'", str48, "2020-11-25T01:49:20.186Z");
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 20 + "'", int49 == 20);
org.junit.Assert.assertNotNull(chronology50);
org.junit.Assert.assertNotNull(mutableDateTime51);
org.junit.Assert.assertNotNull(obj53);
org.junit.Assert.assertEquals(obj53.toString(), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj53), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj53), "1970-01-01T00:00:52.001Z");
org.junit.Assert.assertNotNull(property55);
org.junit.Assert.assertTrue("'" + int56 + "' != '" + 20 + "'", int56 == 20);
org.junit.Assert.assertTrue("'" + int62 + "' != '" + 0 + "'", int62 == 0);
org.junit.Assert.assertTrue("'" + int63 + "' != '" + 19 + "'", int63 == 19);
org.junit.Assert.assertTrue("'" + int67 + "' != '" + 3 + "'", int67 == 3);
org.junit.Assert.assertNotNull(dateTimeZone71);
org.junit.Assert.assertNotNull(mutableDateTime72);
org.junit.Assert.assertNotNull(dateTime74);
org.junit.Assert.assertNotNull(dateTime77);
org.junit.Assert.assertTrue("'" + boolean78 + "' != '" + false + "'", boolean78 == false);
org.junit.Assert.assertTrue("'" + int80 + "' != '" + 1 + "'", int80 == 1);
org.junit.Assert.assertNotNull(property86);
org.junit.Assert.assertNotNull(property87);
org.junit.Assert.assertTrue("'" + boolean90 + "' != '" + false + "'", boolean90 == false);
}
@Test
public void test1953() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1953");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime5 = property4.roundHalfFloor();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime5.millisOfSecond();
org.joda.time.MutableDateTime mutableDateTime8 = property6.set((int) (short) 1);
int int9 = property6.getLeapAmount();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(mutableDateTime5);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
}
@Test
@Ignore
public void test1954() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1954");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime2.add(readablePeriod7);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
mutableDateTime11.setTime((long) '#');
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime18.add(readablePeriod21);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime18.hourOfDay();
java.lang.String str24 = mutableDateTime18.toString();
int int25 = mutableDateTime11.compareTo((org.joda.time.ReadableInstant) mutableDateTime18);
java.lang.Object obj26 = mutableDateTime11.clone();
long long27 = mutableDateTime11.getMillis();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType36 = property35.getFieldType();
int int37 = mutableDateTime11.get(dateTimeFieldType36);
org.joda.time.MutableDateTime.Property property38 = mutableDateTime2.property(dateTimeFieldType36);
org.joda.time.MutableDateTime mutableDateTime40 = property38.add((long) 6353);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.354Z" + "'", str4, "2020-11-25T01:49:20.354Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:20.354Z" + "'", str13, "2020-11-25T01:49:20.354Z");
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:20.354Z" + "'", str20, "2020-11-25T01:49:20.354Z");
org.junit.Assert.assertNotNull(property23);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:20.354Z" + "'", str24, "2020-11-25T01:49:20.354Z");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + (-1) + "'", int25 == (-1));
org.junit.Assert.assertNotNull(obj26);
org.junit.Assert.assertEquals(obj26.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj26), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj26), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long27 + "' != '" + 1606262400035L + "'", long27 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:20.354Z" + "'", str32, "2020-11-25T01:49:20.354Z");
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(dateTimeFieldType36);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 0 + "'", int37 == 0);
org.junit.Assert.assertNotNull(property38);
org.junit.Assert.assertNotNull(mutableDateTime40);
}
@Test
@Ignore
public void test1955() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1955");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
int int3 = mutableDateTime1.getMinuteOfHour();
java.lang.Object obj4 = mutableDateTime1.clone();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) 100, chronology29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:47:23.898Z", chronology29);
org.joda.time.MutableDateTime mutableDateTime34 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property35 = mutableDateTime34.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime36 = property35.getMutableDateTime();
java.lang.Object obj37 = null;
org.joda.time.Chronology chronology38 = null;
org.joda.time.MutableDateTime mutableDateTime39 = new org.joda.time.MutableDateTime(obj37, chronology38);
int int40 = mutableDateTime39.getDayOfWeek();
mutableDateTime39.addSeconds((int) (byte) 0);
int int43 = mutableDateTime39.getSecondOfMinute();
java.lang.Object obj44 = null;
org.joda.time.Chronology chronology45 = null;
org.joda.time.MutableDateTime mutableDateTime46 = new org.joda.time.MutableDateTime(obj44, chronology45);
org.joda.time.format.DateTimeFormatter dateTimeFormatter47 = null;
java.lang.String str48 = mutableDateTime46.toString(dateTimeFormatter47);
mutableDateTime46.setTime((long) '#');
java.lang.Object obj51 = null;
org.joda.time.Chronology chronology52 = null;
org.joda.time.MutableDateTime mutableDateTime53 = new org.joda.time.MutableDateTime(obj51, chronology52);
org.joda.time.format.DateTimeFormatter dateTimeFormatter54 = null;
java.lang.String str55 = mutableDateTime53.toString(dateTimeFormatter54);
org.joda.time.ReadablePeriod readablePeriod56 = null;
mutableDateTime53.add(readablePeriod56);
org.joda.time.MutableDateTime.Property property58 = mutableDateTime53.hourOfDay();
java.lang.String str59 = mutableDateTime53.toString();
int int60 = mutableDateTime46.compareTo((org.joda.time.ReadableInstant) mutableDateTime53);
java.lang.Object obj61 = mutableDateTime46.clone();
long long62 = mutableDateTime46.getMillis();
java.lang.Object obj63 = null;
org.joda.time.Chronology chronology64 = null;
org.joda.time.MutableDateTime mutableDateTime65 = new org.joda.time.MutableDateTime(obj63, chronology64);
org.joda.time.format.DateTimeFormatter dateTimeFormatter66 = null;
java.lang.String str67 = mutableDateTime65.toString(dateTimeFormatter66);
org.joda.time.ReadablePeriod readablePeriod68 = null;
mutableDateTime65.add(readablePeriod68);
org.joda.time.MutableDateTime.Property property70 = mutableDateTime65.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType71 = property70.getFieldType();
int int72 = mutableDateTime46.get(dateTimeFieldType71);
int int73 = mutableDateTime39.get(dateTimeFieldType71);
boolean boolean74 = mutableDateTime36.isSupported(dateTimeFieldType71);
org.joda.time.MutableDateTime.Property property75 = mutableDateTime33.property(dateTimeFieldType71);
boolean boolean76 = mutableDateTime1.isSupported(dateTimeFieldType71);
org.joda.time.MutableDateTime.Property property77 = mutableDateTime1.yearOfCentury();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertNotNull(obj4);
org.junit.Assert.assertEquals(obj4.toString(), "1970-01-01T00:00:00.010Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj4), "1970-01-01T00:00:00.010Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj4), "1970-01-01T00:00:00.010Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:20.400Z" + "'", str11, "2020-11-25T01:49:20.400Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:20.400Z" + "'", str27, "2020-11-25T01:49:20.400Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 3 + "'", int40 == 3);
// flaky: org.junit.Assert.assertTrue("'" + int43 + "' != '" + 20 + "'", int43 == 20);
// flaky: org.junit.Assert.assertEquals("'" + str48 + "' != '" + "2020-11-25T01:49:20.400Z" + "'", str48, "2020-11-25T01:49:20.400Z");
// flaky: org.junit.Assert.assertEquals("'" + str55 + "' != '" + "2020-11-25T01:49:20.400Z" + "'", str55, "2020-11-25T01:49:20.400Z");
org.junit.Assert.assertNotNull(property58);
// flaky: org.junit.Assert.assertEquals("'" + str59 + "' != '" + "2020-11-25T01:49:20.400Z" + "'", str59, "2020-11-25T01:49:20.400Z");
org.junit.Assert.assertTrue("'" + int60 + "' != '" + (-1) + "'", int60 == (-1));
org.junit.Assert.assertNotNull(obj61);
org.junit.Assert.assertEquals(obj61.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj61), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj61), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long62 + "' != '" + 1606262400035L + "'", long62 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str67 + "' != '" + "2020-11-25T01:49:20.400Z" + "'", str67, "2020-11-25T01:49:20.400Z");
org.junit.Assert.assertNotNull(property70);
org.junit.Assert.assertNotNull(dateTimeFieldType71);
org.junit.Assert.assertTrue("'" + int72 + "' != '" + 0 + "'", int72 == 0);
org.junit.Assert.assertTrue("'" + int73 + "' != '" + 1 + "'", int73 == 1);
org.junit.Assert.assertTrue("'" + boolean74 + "' != '" + true + "'", boolean74 == true);
org.junit.Assert.assertNotNull(property75);
org.junit.Assert.assertTrue("'" + boolean76 + "' != '" + true + "'", boolean76 == true);
org.junit.Assert.assertNotNull(property77);
}
@Test
public void test1956() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1956");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime4 = mutableDateTime2.copy();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.DateTimeZone dateTimeZone8 = mutableDateTime7.getZone();
mutableDateTime2.setZone(dateTimeZone8);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime2.weekyear();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(mutableDateTime4);
org.junit.Assert.assertNotNull(dateTimeZone8);
org.junit.Assert.assertNotNull(property10);
}
@Test
@Ignore
public void test1957() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1957");
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.weekyear();
long long11 = property10.remainder();
org.joda.time.DateTimeField dateTimeField12 = property10.getField();
org.joda.time.MutableDateTime mutableDateTime14 = property10.add(1L);
org.joda.time.MutableDateTime.Property property15 = mutableDateTime14.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime16 = mutableDateTime14.copy();
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = org.joda.time.MutableDateTime.now(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(chronology23);
mutableDateTime16.setChronology(chronology23);
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:47:20.702Z", chronology23);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime28 = new org.joda.time.MutableDateTime(36, 14, 6375, 44, 5, 46004, 1971, chronology23);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 44 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertTrue("'" + long11 + "' != '" + 259200010L + "'", long11 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField12);
org.junit.Assert.assertNotNull(mutableDateTime14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime16);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:20.513Z" + "'", str21, "2020-11-25T01:49:20.513Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime25);
}
@Test
@Ignore
public void test1958() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1958");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
int int8 = property7.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.centuryOfEra();
int int11 = mutableDateTime9.getYearOfEra();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.format.DateTimeFormatter dateTimeFormatter15 = null;
java.lang.String str16 = mutableDateTime14.toString(dateTimeFormatter15);
org.joda.time.ReadablePeriod readablePeriod17 = null;
mutableDateTime14.add(readablePeriod17);
org.joda.time.MutableDateTime.Property property19 = mutableDateTime14.hourOfDay();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime14.dayOfWeek();
int int21 = property20.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime23 = property20.addWrapField(0);
boolean boolean24 = mutableDateTime23.isBeforeNow();
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
int int28 = mutableDateTime27.getDayOfWeek();
mutableDateTime27.addSeconds((int) (byte) 0);
org.joda.time.MutableDateTime.Property property31 = mutableDateTime27.secondOfMinute();
org.joda.time.MutableDateTime.Property property32 = mutableDateTime27.weekyear();
java.lang.Object obj33 = null;
org.joda.time.Chronology chronology34 = null;
org.joda.time.MutableDateTime mutableDateTime35 = new org.joda.time.MutableDateTime(obj33, chronology34);
org.joda.time.format.DateTimeFormatter dateTimeFormatter36 = null;
java.lang.String str37 = mutableDateTime35.toString(dateTimeFormatter36);
int int38 = mutableDateTime35.getYearOfCentury();
org.joda.time.Chronology chronology39 = mutableDateTime35.getChronology();
int int40 = mutableDateTime35.getWeekOfWeekyear();
java.lang.Object obj41 = null;
org.joda.time.Chronology chronology42 = null;
org.joda.time.MutableDateTime mutableDateTime43 = new org.joda.time.MutableDateTime(obj41, chronology42);
org.joda.time.DateTimeZone dateTimeZone44 = mutableDateTime43.getZone();
org.joda.time.DateTime dateTime45 = mutableDateTime35.toDateTime(dateTimeZone44);
org.joda.time.MutableDateTime mutableDateTime46 = mutableDateTime35.copy();
boolean boolean47 = mutableDateTime35.isAfterNow();
org.joda.time.MutableDateTime.Property property48 = mutableDateTime35.centuryOfEra();
int int49 = property32.getDifference((org.joda.time.ReadableInstant) mutableDateTime35);
mutableDateTime35.setSecondOfDay(21);
mutableDateTime35.addHours(104);
mutableDateTime35.addWeekyears(3);
org.joda.time.Chronology chronology56 = mutableDateTime35.getChronology();
mutableDateTime23.setChronology(chronology56);
mutableDateTime9.setChronology(chronology56);
org.joda.time.MutableDateTime mutableDateTime59 = org.joda.time.MutableDateTime.now(chronology56);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.604Z" + "'", str4, "2020-11-25T01:49:20.604Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 2020 + "'", int11 == 2020);
// flaky: org.junit.Assert.assertEquals("'" + str16 + "' != '" + "2020-11-25T01:49:20.604Z" + "'", str16, "2020-11-25T01:49:20.604Z");
org.junit.Assert.assertNotNull(property19);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 7 + "'", int21 == 7);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 3 + "'", int28 == 3);
org.junit.Assert.assertNotNull(property31);
org.junit.Assert.assertNotNull(property32);
// flaky: org.junit.Assert.assertEquals("'" + str37 + "' != '" + "2020-11-25T01:49:20.604Z" + "'", str37, "2020-11-25T01:49:20.604Z");
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 20 + "'", int38 == 20);
org.junit.Assert.assertNotNull(chronology39);
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 48 + "'", int40 == 48);
org.junit.Assert.assertNotNull(dateTimeZone44);
org.junit.Assert.assertNotNull(dateTime45);
org.junit.Assert.assertNotNull(mutableDateTime46);
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
org.junit.Assert.assertNotNull(property48);
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 0 + "'", int49 == 0);
org.junit.Assert.assertNotNull(chronology56);
org.junit.Assert.assertNotNull(mutableDateTime59);
}
@Test
@Ignore
public void test1959() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1959");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
org.joda.time.Interval interval4 = property2.toInterval();
java.lang.Object obj5 = null;
org.joda.time.Chronology chronology6 = null;
org.joda.time.MutableDateTime mutableDateTime7 = new org.joda.time.MutableDateTime(obj5, chronology6);
org.joda.time.format.DateTimeFormatter dateTimeFormatter8 = null;
java.lang.String str9 = mutableDateTime7.toString(dateTimeFormatter8);
org.joda.time.ReadablePeriod readablePeriod10 = null;
mutableDateTime7.add(readablePeriod10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime7.yearOfCentury();
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime7.toMutableDateTimeISO();
int int14 = mutableDateTime7.getSecondOfDay();
int int15 = property2.getDifference((org.joda.time.ReadableInstant) mutableDateTime7);
mutableDateTime7.setMinuteOfHour(0);
mutableDateTime7.addMillis(627);
// The following exception was thrown during execution in test generation
try {
mutableDateTime7.setDateTime(6528, (int) (byte) -1, 2400000, (int) (byte) 100, 470, 6528, 565);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 100 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertNotNull(interval4);
// flaky: org.junit.Assert.assertEquals("'" + str9 + "' != '" + "2020-11-25T01:49:20.662Z" + "'", str9, "2020-11-25T01:49:20.662Z");
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertTrue("'" + int14 + "' != '" + 6560 + "'", int14 == 6560);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
}
@Test
@Ignore
public void test1960() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1960");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime7.dayOfYear();
int int9 = mutableDateTime7.getHourOfDay();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.701Z" + "'", str4, "2020-11-25T01:49:20.701Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 1 + "'", int9 == 1);
}
@Test
@Ignore
public void test1961() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1961");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.ReadablePeriod readablePeriod7 = null;
mutableDateTime2.add(readablePeriod7);
java.lang.Object obj9 = null;
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime(obj9, chronology10);
org.joda.time.format.DateTimeFormatter dateTimeFormatter12 = null;
java.lang.String str13 = mutableDateTime11.toString(dateTimeFormatter12);
mutableDateTime11.setTime((long) '#');
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
org.joda.time.ReadablePeriod readablePeriod21 = null;
mutableDateTime18.add(readablePeriod21);
org.joda.time.MutableDateTime.Property property23 = mutableDateTime18.hourOfDay();
java.lang.String str24 = mutableDateTime18.toString();
int int25 = mutableDateTime11.compareTo((org.joda.time.ReadableInstant) mutableDateTime18);
java.lang.Object obj26 = mutableDateTime11.clone();
long long27 = mutableDateTime11.getMillis();
java.lang.Object obj28 = null;
org.joda.time.Chronology chronology29 = null;
org.joda.time.MutableDateTime mutableDateTime30 = new org.joda.time.MutableDateTime(obj28, chronology29);
org.joda.time.format.DateTimeFormatter dateTimeFormatter31 = null;
java.lang.String str32 = mutableDateTime30.toString(dateTimeFormatter31);
org.joda.time.ReadablePeriod readablePeriod33 = null;
mutableDateTime30.add(readablePeriod33);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime30.hourOfDay();
org.joda.time.DateTimeFieldType dateTimeFieldType36 = property35.getFieldType();
int int37 = mutableDateTime11.get(dateTimeFieldType36);
org.joda.time.MutableDateTime.Property property38 = mutableDateTime2.property(dateTimeFieldType36);
java.util.Locale locale40 = null;
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime41 = property38.set("2020-11-25T01:47:49.301Z", locale40);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value \"2020-11-25T01:47:49.301Z\" for hourOfDay is not supported");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.725Z" + "'", str4, "2020-11-25T01:49:20.725Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
// flaky: org.junit.Assert.assertEquals("'" + str13 + "' != '" + "2020-11-25T01:49:20.726Z" + "'", str13, "2020-11-25T01:49:20.726Z");
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:20.726Z" + "'", str20, "2020-11-25T01:49:20.726Z");
org.junit.Assert.assertNotNull(property23);
// flaky: org.junit.Assert.assertEquals("'" + str24 + "' != '" + "2020-11-25T01:49:20.726Z" + "'", str24, "2020-11-25T01:49:20.726Z");
org.junit.Assert.assertTrue("'" + int25 + "' != '" + (-1) + "'", int25 == (-1));
org.junit.Assert.assertNotNull(obj26);
org.junit.Assert.assertEquals(obj26.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj26), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj26), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long27 + "' != '" + 1606262400035L + "'", long27 == 1606262400035L);
// flaky: org.junit.Assert.assertEquals("'" + str32 + "' != '" + "2020-11-25T01:49:20.726Z" + "'", str32, "2020-11-25T01:49:20.726Z");
org.junit.Assert.assertNotNull(property35);
org.junit.Assert.assertNotNull(dateTimeFieldType36);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 0 + "'", int37 == 0);
org.junit.Assert.assertNotNull(property38);
}
@Test
public void test1962() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1962");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) 'a');
int int2 = mutableDateTime1.getDayOfWeek();
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime1.getZone();
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 4 + "'", int2 == 4);
org.junit.Assert.assertNotNull(dateTimeZone3);
}
@Test
public void test1963() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1963");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime mutableDateTime8 = property7.roundCeiling();
org.joda.time.MutableDateTime mutableDateTime10 = property7.add((long) 5);
int int11 = property7.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime13 = property7.add(6481);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.789Z" + "'", str4, "2020-11-25T01:49:20.789Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 23 + "'", int11 == 23);
org.junit.Assert.assertNotNull(mutableDateTime13);
}
@Test
@Ignore
public void test1964() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1964");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.year();
java.lang.String str15 = mutableDateTime12.toString("330");
mutableDateTime12.addMinutes(0);
org.joda.time.ReadableDuration readableDuration18 = null;
mutableDateTime12.add(readableDuration18);
boolean boolean20 = mutableDateTime12.isAfterNow();
java.util.Date date21 = mutableDateTime12.toDate();
boolean boolean23 = mutableDateTime12.equals((java.lang.Object) "2020-11-25T01:47:43.681Z");
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:20.824Z" + "'", str4, "2020-11-25T01:49:20.824Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertEquals("'" + str15 + "' != '" + "330" + "'", str15, "330");
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
org.junit.Assert.assertNotNull(date21);
org.junit.Assert.assertEquals(date21.toString(), "Wed Nov 25 00:00:00 UTC 2020");
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
}
@Test
public void test1965() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1965");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
int int3 = mutableDateTime1.getMinuteOfHour();
int int4 = mutableDateTime1.getDayOfMonth();
mutableDateTime1.addWeekyears(6319);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime1.dayOfYear();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
org.junit.Assert.assertNotNull(property7);
}
@Test
public void test1966() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1966");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime3 = property2.roundHalfCeiling();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime3.millisOfDay();
org.joda.time.DateTimeZone dateTimeZone5 = mutableDateTime3.getZone();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertNotNull(mutableDateTime3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(dateTimeZone5);
}
@Test
public void test1967() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1967");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((-50L));
int int2 = mutableDateTime1.getCenturyOfEra();
java.util.GregorianCalendar gregorianCalendar3 = mutableDateTime1.toGregorianCalendar();
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 19 + "'", int2 == 19);
org.junit.Assert.assertNotNull(gregorianCalendar3);
}
@Test
@Ignore
public void test1968() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1968");
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology8);
mutableDateTime9.setSecondOfMinute((int) '4');
java.lang.Object obj13 = null;
org.joda.time.Chronology chronology14 = null;
org.joda.time.MutableDateTime mutableDateTime15 = new org.joda.time.MutableDateTime(obj13, chronology14);
org.joda.time.format.DateTimeFormatter dateTimeFormatter16 = null;
java.lang.String str17 = mutableDateTime15.toString(dateTimeFormatter16);
org.joda.time.ReadablePeriod readablePeriod18 = null;
mutableDateTime15.add(readablePeriod18);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime15.hourOfDay();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime15.dayOfWeek();
int int22 = property21.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime24 = property21.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime25 = property21.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod26 = null;
mutableDateTime25.add(readablePeriod26, 40);
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.format.DateTimeFormatter dateTimeFormatter32 = null;
java.lang.String str33 = mutableDateTime31.toString(dateTimeFormatter32);
int int34 = mutableDateTime31.getYearOfCentury();
org.joda.time.Chronology chronology35 = mutableDateTime31.getChronology();
org.joda.time.MutableDateTime mutableDateTime36 = mutableDateTime25.toMutableDateTime(chronology35);
org.joda.time.MutableDateTime mutableDateTime37 = new org.joda.time.MutableDateTime((long) 100, chronology35);
org.joda.time.MutableDateTime mutableDateTime38 = org.joda.time.MutableDateTime.now(chronology35);
org.joda.time.MutableDateTime mutableDateTime39 = mutableDateTime9.toMutableDateTime(chronology35);
// The following exception was thrown during execution in test generation
try {
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime(46, 69, 330, 6330255, 6549032, 53, (-9), chronology35);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6330255 for hourOfDay must be in the range [0,23]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str17 + "' != '" + "2020-11-25T01:49:21.007Z" + "'", str17, "2020-11-25T01:49:21.007Z");
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 7 + "'", int22 == 7);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(mutableDateTime25);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:49:21.007Z" + "'", str33, "2020-11-25T01:49:21.007Z");
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 20 + "'", int34 == 20);
org.junit.Assert.assertNotNull(chronology35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertNotNull(mutableDateTime38);
org.junit.Assert.assertNotNull(mutableDateTime39);
}
@Test
@Ignore
public void test1969() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1969");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property15.add(2189);
java.lang.String str18 = mutableDateTime17.toString();
int int19 = mutableDateTime17.getDayOfYear();
org.joda.time.MutableDateTime.Property property20 = mutableDateTime17.dayOfWeek();
int int21 = mutableDateTime17.getDayOfMonth();
org.joda.time.Chronology chronology23 = null;
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology23);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime26 = property25.roundCeiling();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime26.minuteOfHour();
int int28 = mutableDateTime26.getYearOfEra();
boolean boolean29 = mutableDateTime17.isBefore((org.joda.time.ReadableInstant) mutableDateTime26);
mutableDateTime26.setMillisOfSecond(40);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.055Z" + "'", str4, "2020-11-25T01:49:21.055Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T02:25:50.055Z" + "'", str18, "2020-11-25T02:25:50.055Z");
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 330 + "'", int19 == 330);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 25 + "'", int21 == 25);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 1970 + "'", int28 == 1970);
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + false + "'", boolean29 == false);
}
@Test
@Ignore
public void test1970() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1970");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
org.joda.time.DurationField durationField9 = property8.getRangeDurationField();
boolean boolean10 = property8.isLeap();
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime13 = property12.getMutableDateTime();
org.joda.time.DateTime dateTime14 = mutableDateTime13.toDateTimeISO();
int int15 = property8.getDifference((org.joda.time.ReadableInstant) dateTime14);
org.joda.time.MutableDateTime mutableDateTime16 = property8.roundHalfCeiling();
boolean boolean17 = property8.isLeap();
org.joda.time.DateTimeField dateTimeField18 = property8.getField();
java.util.Locale locale19 = null;
java.lang.String str20 = property8.getAsShortText(locale19);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.121Z" + "'", str4, "2020-11-25T01:49:21.121Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(durationField9);
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(dateTime14);
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
org.junit.Assert.assertNotNull(dateTimeField18);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "Wed" + "'", str20, "Wed");
}
@Test
@Ignore
public void test1971() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1971");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
java.lang.String str3 = property2.getAsString();
java.lang.String str4 = property2.getAsString();
org.joda.time.MutableDateTime mutableDateTime5 = property2.roundCeiling();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertEquals("'" + str3 + "' != '" + "25" + "'", str3, "25");
org.junit.Assert.assertEquals("'" + str4 + "' != '" + "25" + "'", str4, "25");
org.junit.Assert.assertNotNull(mutableDateTime5);
}
@Test
@Ignore
public void test1972() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1972");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.DateTimeField dateTimeField6 = mutableDateTime3.getRoundingField();
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology8);
mutableDateTime9.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property12 = mutableDateTime9.minuteOfDay();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime9.year();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.hourOfDay();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime16.dayOfWeek();
int int23 = property22.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime25 = property22.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime26 = property22.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod27 = null;
mutableDateTime26.add(readablePeriod27, 40);
java.lang.Object obj30 = null;
org.joda.time.Chronology chronology31 = null;
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(obj30, chronology31);
org.joda.time.format.DateTimeFormatter dateTimeFormatter33 = null;
java.lang.String str34 = mutableDateTime32.toString(dateTimeFormatter33);
int int35 = mutableDateTime32.getYearOfCentury();
org.joda.time.Chronology chronology36 = mutableDateTime32.getChronology();
org.joda.time.MutableDateTime mutableDateTime37 = mutableDateTime26.toMutableDateTime(chronology36);
mutableDateTime9.setChronology(chronology36);
mutableDateTime3.setChronology(chronology36);
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime((long) 105, chronology36);
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:21.185Z" + "'", str5, "2020-11-25T01:49:21.185Z");
org.junit.Assert.assertNull(dateTimeField6);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertNotNull(property13);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:21.185Z" + "'", str18, "2020-11-25T01:49:21.185Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertTrue("'" + int23 + "' != '" + 7 + "'", int23 == 7);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertNotNull(mutableDateTime26);
// flaky: org.junit.Assert.assertEquals("'" + str34 + "' != '" + "2020-11-25T01:49:21.185Z" + "'", str34, "2020-11-25T01:49:21.185Z");
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 20 + "'", int35 == 20);
org.junit.Assert.assertNotNull(chronology36);
org.junit.Assert.assertNotNull(mutableDateTime37);
}
@Test
public void test1973() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1973");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property1 = mutableDateTime0.dayOfMonth();
org.joda.time.MutableDateTime.Property property2 = mutableDateTime0.dayOfMonth();
boolean boolean3 = mutableDateTime0.isBeforeNow();
java.lang.String str4 = mutableDateTime0.toString();
org.junit.Assert.assertNotNull(property1);
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + boolean3 + "' != '" + false + "'", boolean3 == false);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.237Z" + "'", str4, "2020-11-25T01:49:21.237Z");
}
@Test
@Ignore
public void test1974() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1974");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
org.joda.time.MutableDateTime mutableDateTime17 = mutableDateTime2.copy();
long long18 = mutableDateTime17.getMillis();
int int19 = mutableDateTime17.getSecondOfMinute();
boolean boolean20 = mutableDateTime17.isAfterNow();
org.joda.time.MutableDateTime.Property property21 = mutableDateTime17.centuryOfEra();
org.joda.time.ReadableDuration readableDuration22 = null;
mutableDateTime17.add(readableDuration22);
java.lang.Object obj25 = null;
org.joda.time.Chronology chronology26 = null;
org.joda.time.MutableDateTime mutableDateTime27 = new org.joda.time.MutableDateTime(obj25, chronology26);
org.joda.time.DateTimeZone dateTimeZone28 = mutableDateTime27.getZone();
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone28);
org.joda.time.DateTime dateTime30 = mutableDateTime29.toDateTimeISO();
java.util.Date date31 = mutableDateTime29.toDate();
int int32 = mutableDateTime29.getYear();
boolean boolean33 = mutableDateTime17.isEqual((org.joda.time.ReadableInstant) mutableDateTime29);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.274Z" + "'", str4, "2020-11-25T01:49:21.274Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:21.274Z" + "'", str11, "2020-11-25T01:49:21.274Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:21.274Z" + "'", str15, "2020-11-25T01:49:21.274Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertTrue("'" + long18 + "' != '" + 1606262400035L + "'", long18 == 1606262400035L);
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 0 + "'", int19 == 0);
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(dateTimeZone28);
org.junit.Assert.assertNotNull(dateTime30);
org.junit.Assert.assertNotNull(date31);
org.junit.Assert.assertEquals(date31.toString(), "Wed Nov 25 01:44:41 UTC 2020");
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 2020 + "'", int32 == 2020);
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
}
@Test
public void test1975() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1975");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.addDays((int) (byte) 100);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.secondOfMinute();
int int8 = property7.getMaximumValue();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundHalfFloor();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.secondOfMinute();
mutableDateTime9.setYear(0);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 59 + "'", int8 == 59);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
}
@Test
@Ignore
public void test1976() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1976");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
int int3 = mutableDateTime2.getDayOfWeek();
mutableDateTime2.addSeconds((int) (byte) 0);
mutableDateTime2.setDayOfYear((int) ' ');
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.millisOfSecond();
int int9 = property8.get();
java.lang.Object obj10 = null;
org.joda.time.Chronology chronology11 = null;
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime(obj10, chronology11);
org.joda.time.format.DateTimeFormatter dateTimeFormatter13 = null;
java.lang.String str14 = mutableDateTime12.toString(dateTimeFormatter13);
org.joda.time.ReadablePeriod readablePeriod15 = null;
mutableDateTime12.add(readablePeriod15);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime12.hourOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime12.dayOfWeek();
org.joda.time.DurationField durationField19 = property18.getRangeDurationField();
boolean boolean20 = property18.isLeap();
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property22 = mutableDateTime21.dayOfMonth();
org.joda.time.MutableDateTime mutableDateTime23 = property22.getMutableDateTime();
org.joda.time.DateTime dateTime24 = mutableDateTime23.toDateTimeISO();
int int25 = property18.getDifference((org.joda.time.ReadableInstant) dateTime24);
org.joda.time.MutableDateTime mutableDateTime26 = property18.roundHalfCeiling();
org.joda.time.MutableDateTime mutableDateTime27 = property18.roundCeiling();
boolean boolean28 = property8.equals((java.lang.Object) mutableDateTime27);
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.format.DateTimeFormatter dateTimeFormatter32 = null;
java.lang.String str33 = mutableDateTime31.toString(dateTimeFormatter32);
int int34 = mutableDateTime31.getYearOfCentury();
org.joda.time.Chronology chronology35 = mutableDateTime31.getChronology();
org.joda.time.MutableDateTime mutableDateTime36 = org.joda.time.MutableDateTime.now(chronology35);
int int37 = mutableDateTime27.compareTo((org.joda.time.ReadableInstant) mutableDateTime36);
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3 + "'", int3 == 3);
org.junit.Assert.assertNotNull(property8);
// flaky: org.junit.Assert.assertTrue("'" + int9 + "' != '" + 383 + "'", int9 == 383);
// flaky: org.junit.Assert.assertEquals("'" + str14 + "' != '" + "2020-11-25T01:49:21.383Z" + "'", str14, "2020-11-25T01:49:21.383Z");
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(durationField19);
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
org.junit.Assert.assertNotNull(property22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(dateTime24);
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 0 + "'", int25 == 0);
org.junit.Assert.assertNotNull(mutableDateTime26);
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
// flaky: org.junit.Assert.assertEquals("'" + str33 + "' != '" + "2020-11-25T01:49:21.383Z" + "'", str33, "2020-11-25T01:49:21.383Z");
org.junit.Assert.assertTrue("'" + int34 + "' != '" + 20 + "'", int34 == 20);
org.junit.Assert.assertNotNull(chronology35);
org.junit.Assert.assertNotNull(mutableDateTime36);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + (-1) + "'", int37 == (-1));
}
@Test
public void test1977() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1977");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
mutableDateTime2.setSecondOfDay((int) '#');
mutableDateTime2.setTime((int) (short) 10, (int) '#', 49, (int) (byte) 10);
mutableDateTime2.addDays((int) '4');
org.joda.time.MutableDateTime.Property property13 = mutableDateTime2.dayOfWeek();
org.joda.time.MutableDateTime.Property property14 = mutableDateTime2.minuteOfDay();
java.util.Locale locale15 = null;
int int16 = property14.getMaximumTextLength(locale15);
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 4 + "'", int16 == 4);
}
@Test
public void test1978() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1978");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
org.joda.time.MutableDateTime mutableDateTime7 = property5.addWrapField(21);
// The following exception was thrown during execution in test generation
try {
mutableDateTime7.setMinuteOfDay(6317185);
org.junit.Assert.fail("Expected exception of type org.joda.time.IllegalFieldValueException; message: Value 6317185 for minuteOfDay must be in the range [0,1439]");
} catch (org.joda.time.IllegalFieldValueException e) {
// Expected exception.
}
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(mutableDateTime7);
}
@Test
@Ignore
public void test1979() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1979");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.Instant instant3 = mutableDateTime2.toInstant();
org.joda.time.MutableDateTime.Property property4 = mutableDateTime2.monthOfYear();
mutableDateTime2.setMonthOfYear((int) (byte) 10);
mutableDateTime2.addWeeks((int) (short) 10);
int int9 = mutableDateTime2.getYearOfEra();
int int10 = mutableDateTime2.getWeekyear();
org.junit.Assert.assertNotNull(instant3);
org.junit.Assert.assertNotNull(property4);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 2021 + "'", int9 == 2021);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 2020 + "'", int10 == 2020);
}
@Test
@Ignore
public void test1980() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1980");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.centuryOfEra();
org.joda.time.ReadableInstant readableInstant8 = null;
mutableDateTime2.setDate(readableInstant8);
java.util.Date date10 = mutableDateTime2.toDate();
org.joda.time.MutableDateTime mutableDateTime12 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.weekyear();
long long14 = property13.remainder();
org.joda.time.DateTimeField dateTimeField15 = property13.getField();
org.joda.time.MutableDateTime mutableDateTime17 = property13.add(1L);
mutableDateTime17.setDayOfYear((int) (short) 100);
org.joda.time.MutableDateTime.Property property20 = mutableDateTime17.millisOfSecond();
boolean boolean21 = mutableDateTime2.equals((java.lang.Object) property20);
java.lang.String str22 = property20.toString();
long long23 = property20.remainder();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.544Z" + "'", str4, "2020-11-25T01:49:21.544Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(date10);
// flaky: org.junit.Assert.assertEquals(date10.toString(), "Wed Nov 25 01:49:21 UTC 2020");
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertTrue("'" + long14 + "' != '" + 259200010L + "'", long14 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField15);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property20);
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "Property[millisOfSecond]" + "'", str22, "Property[millisOfSecond]");
org.junit.Assert.assertTrue("'" + long23 + "' != '" + 0L + "'", long23 == 0L);
}
@Test
public void test1981() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1981");
org.joda.time.MutableDateTime mutableDateTime1 = org.joda.time.MutableDateTime.parse("2020-11-25T01:47:30.683Z");
mutableDateTime1.setMillis((long) 635);
org.junit.Assert.assertNotNull(mutableDateTime1);
}
@Test
@Ignore
public void test1982() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1982");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
java.lang.Object obj17 = mutableDateTime2.clone();
long long18 = mutableDateTime2.getMillis();
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2);
mutableDateTime19.setYear(6382);
mutableDateTime19.addWeeks(6429);
int int24 = mutableDateTime19.getWeekOfWeekyear();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.610Z" + "'", str4, "2020-11-25T01:49:21.610Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:21.610Z" + "'", str11, "2020-11-25T01:49:21.610Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:21.610Z" + "'", str15, "2020-11-25T01:49:21.610Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertNotNull(obj17);
org.junit.Assert.assertEquals(obj17.toString(), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.lang.String.valueOf(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertEquals(java.util.Objects.toString(obj17), "2020-11-25T00:00:00.035Z");
org.junit.Assert.assertTrue("'" + long18 + "' != '" + 1606262400035L + "'", long18 == 1606262400035L);
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 6 + "'", int24 == 6);
}
@Test
@Ignore
public void test1983() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1983");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime9.dayOfWeek();
int int16 = property15.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime18 = property15.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime19 = property15.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod20 = null;
mutableDateTime19.add(readablePeriod20, 40);
java.lang.Object obj23 = null;
org.joda.time.Chronology chronology24 = null;
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime(obj23, chronology24);
org.joda.time.format.DateTimeFormatter dateTimeFormatter26 = null;
java.lang.String str27 = mutableDateTime25.toString(dateTimeFormatter26);
int int28 = mutableDateTime25.getYearOfCentury();
org.joda.time.Chronology chronology29 = mutableDateTime25.getChronology();
org.joda.time.MutableDateTime mutableDateTime30 = mutableDateTime19.toMutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime((long) 100, chronology29);
org.joda.time.MutableDateTime mutableDateTime32 = new org.joda.time.MutableDateTime(chronology29);
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((java.lang.Object) mutableDateTime2, chronology29);
org.joda.time.MutableDateTime mutableDateTime34 = org.joda.time.MutableDateTime.now(chronology29);
org.joda.time.MutableDateTime mutableDateTime35 = org.joda.time.MutableDateTime.now(chronology29);
java.lang.Object obj36 = null;
org.joda.time.Chronology chronology37 = null;
org.joda.time.MutableDateTime mutableDateTime38 = new org.joda.time.MutableDateTime(obj36, chronology37);
org.joda.time.format.DateTimeFormatter dateTimeFormatter39 = null;
java.lang.String str40 = mutableDateTime38.toString(dateTimeFormatter39);
org.joda.time.ReadablePeriod readablePeriod41 = null;
mutableDateTime38.add(readablePeriod41);
org.joda.time.MutableDateTime.Property property43 = mutableDateTime38.hourOfDay();
org.joda.time.MutableDateTime.Property property44 = mutableDateTime38.dayOfWeek();
int int45 = property44.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime47 = property44.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime48 = property44.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod49 = null;
mutableDateTime48.add(readablePeriod49, 40);
mutableDateTime48.setMinuteOfHour(1);
org.joda.time.MutableDateTime mutableDateTime54 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property55 = mutableDateTime54.dayOfMonth();
org.joda.time.MutableDateTime.Property property56 = mutableDateTime54.dayOfMonth();
java.lang.String str57 = property56.getAsString();
org.joda.time.Interval interval58 = property56.toInterval();
java.lang.Object obj59 = null;
org.joda.time.Chronology chronology60 = null;
org.joda.time.MutableDateTime mutableDateTime61 = new org.joda.time.MutableDateTime(obj59, chronology60);
org.joda.time.format.DateTimeFormatter dateTimeFormatter62 = null;
java.lang.String str63 = mutableDateTime61.toString(dateTimeFormatter62);
org.joda.time.ReadablePeriod readablePeriod64 = null;
mutableDateTime61.add(readablePeriod64);
org.joda.time.MutableDateTime.Property property66 = mutableDateTime61.centuryOfEra();
boolean boolean67 = property56.equals((java.lang.Object) mutableDateTime61);
mutableDateTime61.setTime((long) ' ');
int int70 = mutableDateTime61.getSecondOfMinute();
org.joda.time.MutableDateTime.Property property71 = mutableDateTime61.yearOfEra();
java.lang.Object obj74 = null;
org.joda.time.Chronology chronology75 = null;
org.joda.time.MutableDateTime mutableDateTime76 = new org.joda.time.MutableDateTime(obj74, chronology75);
org.joda.time.DateTimeZone dateTimeZone77 = mutableDateTime76.getZone();
org.joda.time.MutableDateTime mutableDateTime78 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:44:41.430Z", dateTimeZone77);
org.joda.time.MutableDateTime mutableDateTime79 = new org.joda.time.MutableDateTime((long) 627, dateTimeZone77);
mutableDateTime79.setSecondOfMinute((int) (short) 0);
org.joda.time.ReadableDuration readableDuration82 = null;
mutableDateTime79.add(readableDuration82);
org.joda.time.MutableDateTime mutableDateTime84 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property85 = mutableDateTime84.dayOfMonth();
boolean boolean87 = mutableDateTime84.isBefore((long) 9);
org.joda.time.Chronology chronology88 = mutableDateTime84.getChronology();
org.joda.time.MutableDateTime mutableDateTime89 = org.joda.time.MutableDateTime.now(chronology88);
mutableDateTime79.setChronology(chronology88);
org.joda.time.MutableDateTime mutableDateTime91 = mutableDateTime61.toMutableDateTime(chronology88);
org.joda.time.DateTime dateTime92 = mutableDateTime48.toDateTime(chronology88);
org.joda.time.DateTime dateTime93 = mutableDateTime35.toDateTime(chronology88);
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:21.650Z" + "'", str11, "2020-11-25T01:49:21.650Z");
org.junit.Assert.assertNotNull(property14);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 7 + "'", int16 == 7);
org.junit.Assert.assertNotNull(mutableDateTime18);
org.junit.Assert.assertNotNull(mutableDateTime19);
// flaky: org.junit.Assert.assertEquals("'" + str27 + "' != '" + "2020-11-25T01:49:21.650Z" + "'", str27, "2020-11-25T01:49:21.650Z");
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 20 + "'", int28 == 20);
org.junit.Assert.assertNotNull(chronology29);
org.junit.Assert.assertNotNull(mutableDateTime30);
org.junit.Assert.assertNotNull(mutableDateTime34);
org.junit.Assert.assertNotNull(mutableDateTime35);
// flaky: org.junit.Assert.assertEquals("'" + str40 + "' != '" + "2020-11-25T01:49:21.651Z" + "'", str40, "2020-11-25T01:49:21.651Z");
org.junit.Assert.assertNotNull(property43);
org.junit.Assert.assertNotNull(property44);
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 7 + "'", int45 == 7);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertNotNull(mutableDateTime48);
org.junit.Assert.assertNotNull(property55);
org.junit.Assert.assertNotNull(property56);
org.junit.Assert.assertEquals("'" + str57 + "' != '" + "25" + "'", str57, "25");
org.junit.Assert.assertNotNull(interval58);
// flaky: org.junit.Assert.assertEquals("'" + str63 + "' != '" + "2020-11-25T01:49:21.651Z" + "'", str63, "2020-11-25T01:49:21.651Z");
org.junit.Assert.assertNotNull(property66);
org.junit.Assert.assertTrue("'" + boolean67 + "' != '" + false + "'", boolean67 == false);
org.junit.Assert.assertTrue("'" + int70 + "' != '" + 0 + "'", int70 == 0);
org.junit.Assert.assertNotNull(property71);
org.junit.Assert.assertNotNull(dateTimeZone77);
org.junit.Assert.assertNotNull(property85);
org.junit.Assert.assertTrue("'" + boolean87 + "' != '" + false + "'", boolean87 == false);
org.junit.Assert.assertNotNull(chronology88);
org.junit.Assert.assertNotNull(mutableDateTime89);
org.junit.Assert.assertNotNull(mutableDateTime91);
org.junit.Assert.assertNotNull(dateTime92);
org.junit.Assert.assertNotNull(dateTime93);
}
@Test
@Ignore
public void test1984() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1984");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
mutableDateTime2.setTime((long) '#');
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
org.joda.time.ReadablePeriod readablePeriod12 = null;
mutableDateTime9.add(readablePeriod12);
org.joda.time.MutableDateTime.Property property14 = mutableDateTime9.hourOfDay();
java.lang.String str15 = mutableDateTime9.toString();
int int16 = mutableDateTime2.compareTo((org.joda.time.ReadableInstant) mutableDateTime9);
mutableDateTime9.addDays(19);
mutableDateTime9.setMillisOfDay(49);
org.joda.time.format.DateTimeFormatter dateTimeFormatter21 = null;
java.lang.String str22 = mutableDateTime9.toString(dateTimeFormatter21);
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime9.toMutableDateTime();
org.joda.time.MutableDateTime.Property property24 = mutableDateTime23.secondOfMinute();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.852Z" + "'", str4, "2020-11-25T01:49:21.852Z");
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:21.852Z" + "'", str11, "2020-11-25T01:49:21.852Z");
org.junit.Assert.assertNotNull(property14);
// flaky: org.junit.Assert.assertEquals("'" + str15 + "' != '" + "2020-11-25T01:49:21.852Z" + "'", str15, "2020-11-25T01:49:21.852Z");
org.junit.Assert.assertTrue("'" + int16 + "' != '" + (-1) + "'", int16 == (-1));
org.junit.Assert.assertEquals("'" + str22 + "' != '" + "2020-12-14T00:00:00.049Z" + "'", str22, "2020-12-14T00:00:00.049Z");
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(property24);
}
@Test
@Ignore
public void test1985() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1985");
org.joda.time.MutableDateTime mutableDateTime0 = new org.joda.time.MutableDateTime();
int int1 = mutableDateTime0.getEra();
int int2 = mutableDateTime0.getWeekyear();
org.junit.Assert.assertTrue("'" + int1 + "' != '" + 1 + "'", int1 == 1);
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 2020 + "'", int2 == 2020);
}
@Test
@Ignore
public void test1986() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1986");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
org.joda.time.MutableDateTime mutableDateTime7 = org.joda.time.MutableDateTime.now(chronology6);
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology9);
org.joda.time.MutableDateTime.Property property11 = mutableDateTime10.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime13 = property11.add((long) (short) -1);
mutableDateTime13.setWeekOfWeekyear((int) '4');
mutableDateTime7.setTime((org.joda.time.ReadableInstant) mutableDateTime13);
org.joda.time.MutableDateTime.Property property17 = mutableDateTime13.secondOfDay();
org.joda.time.MutableDateTime.Property property18 = mutableDateTime13.secondOfMinute();
java.lang.Object obj19 = null;
org.joda.time.Chronology chronology20 = null;
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime(obj19, chronology20);
org.joda.time.format.DateTimeFormatter dateTimeFormatter22 = null;
java.lang.String str23 = mutableDateTime21.toString(dateTimeFormatter22);
org.joda.time.ReadablePeriod readablePeriod24 = null;
mutableDateTime21.add(readablePeriod24);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime21.yearOfCentury();
org.joda.time.MutableDateTime.Property property27 = mutableDateTime21.dayOfWeek();
org.joda.time.DateTimeFieldType dateTimeFieldType28 = property27.getFieldType();
int int29 = mutableDateTime13.get(dateTimeFieldType28);
int int30 = mutableDateTime13.getDayOfWeek();
int int31 = mutableDateTime13.getDayOfWeek();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.925Z" + "'", str4, "2020-11-25T01:49:21.925Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertNotNull(mutableDateTime7);
org.junit.Assert.assertNotNull(property11);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertNotNull(property17);
org.junit.Assert.assertNotNull(property18);
// flaky: org.junit.Assert.assertEquals("'" + str23 + "' != '" + "2020-11-25T01:49:21.926Z" + "'", str23, "2020-11-25T01:49:21.926Z");
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(property27);
org.junit.Assert.assertNotNull(dateTimeFieldType28);
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 3 + "'", int29 == 3);
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 3 + "'", int30 == 3);
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 3 + "'", int31 == 3);
}
@Test
@Ignore
public void test1987() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1987");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
int int5 = mutableDateTime2.getYearOfCentury();
org.joda.time.Chronology chronology6 = mutableDateTime2.getChronology();
int int7 = mutableDateTime2.getWeekOfWeekyear();
java.lang.Object obj8 = null;
org.joda.time.Chronology chronology9 = null;
org.joda.time.MutableDateTime mutableDateTime10 = new org.joda.time.MutableDateTime(obj8, chronology9);
org.joda.time.DateTimeZone dateTimeZone11 = mutableDateTime10.getZone();
org.joda.time.DateTime dateTime12 = mutableDateTime2.toDateTime(dateTimeZone11);
org.joda.time.MutableDateTime mutableDateTime13 = mutableDateTime2.copy();
boolean boolean14 = mutableDateTime2.isAfterNow();
org.joda.time.MutableDateTime.Property property15 = mutableDateTime2.secondOfDay();
org.joda.time.MutableDateTime mutableDateTime17 = property15.add(2189);
org.joda.time.MutableDateTime.Property property18 = mutableDateTime17.dayOfYear();
org.joda.time.MutableDateTime mutableDateTime19 = property18.getMutableDateTime();
java.lang.String str20 = property18.getAsShortText();
int int21 = property18.getMaximumValueOverall();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:21.975Z" + "'", str4, "2020-11-25T01:49:21.975Z");
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 20 + "'", int5 == 20);
org.junit.Assert.assertNotNull(chronology6);
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 48 + "'", int7 == 48);
org.junit.Assert.assertNotNull(dateTimeZone11);
org.junit.Assert.assertNotNull(dateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
org.junit.Assert.assertNotNull(property15);
org.junit.Assert.assertNotNull(mutableDateTime17);
org.junit.Assert.assertNotNull(property18);
org.junit.Assert.assertNotNull(mutableDateTime19);
org.junit.Assert.assertEquals("'" + str20 + "' != '" + "330" + "'", str20, "330");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 366 + "'", int21 == 366);
}
@Test
@Ignore
public void test1988() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1988");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.DateTimeZone dateTimeZone3 = mutableDateTime2.getZone();
int int4 = mutableDateTime2.getSecondOfMinute();
int int5 = mutableDateTime2.getMonthOfYear();
int int6 = mutableDateTime2.getMillisOfSecond();
int int7 = mutableDateTime2.getMinuteOfHour();
int int8 = mutableDateTime2.getDayOfMonth();
int int9 = mutableDateTime2.getYear();
org.junit.Assert.assertNotNull(dateTimeZone3);
// flaky: org.junit.Assert.assertTrue("'" + int4 + "' != '" + 22 + "'", int4 == 22);
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 11 + "'", int5 == 11);
// flaky: org.junit.Assert.assertTrue("'" + int6 + "' != '" + 25 + "'", int6 == 25);
// flaky: org.junit.Assert.assertTrue("'" + int7 + "' != '" + 49 + "'", int7 == 49);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 25 + "'", int8 == 25);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 2020 + "'", int9 == 2020);
}
@Test
public void test1989() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1989");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) 56871817);
}
@Test
@Ignore
public void test1990() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1990");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod13 = null;
mutableDateTime12.add(readablePeriod13, 40);
java.lang.Object obj16 = null;
org.joda.time.Chronology chronology17 = null;
org.joda.time.MutableDateTime mutableDateTime18 = new org.joda.time.MutableDateTime(obj16, chronology17);
org.joda.time.format.DateTimeFormatter dateTimeFormatter19 = null;
java.lang.String str20 = mutableDateTime18.toString(dateTimeFormatter19);
int int21 = mutableDateTime18.getYearOfCentury();
org.joda.time.Chronology chronology22 = mutableDateTime18.getChronology();
org.joda.time.MutableDateTime mutableDateTime23 = mutableDateTime12.toMutableDateTime(chronology22);
org.joda.time.MutableDateTime mutableDateTime24 = org.joda.time.MutableDateTime.now(chronology22);
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfYear();
int int26 = mutableDateTime24.getYearOfCentury();
mutableDateTime24.setMillisOfDay(18);
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:22.089Z" + "'", str4, "2020-11-25T01:49:22.089Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
// flaky: org.junit.Assert.assertEquals("'" + str20 + "' != '" + "2020-11-25T01:49:22.089Z" + "'", str20, "2020-11-25T01:49:22.089Z");
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 20 + "'", int21 == 20);
org.junit.Assert.assertNotNull(chronology22);
org.junit.Assert.assertNotNull(mutableDateTime23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
}
@Test
@Ignore
public void test1991() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1991");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime12 = property8.roundHalfEven();
org.joda.time.MutableDateTime.Property property13 = mutableDateTime12.minuteOfHour();
int int14 = mutableDateTime12.getMillisOfDay();
mutableDateTime12.setMillis((long) 6464264);
int int17 = mutableDateTime12.getHourOfDay();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:22.124Z" + "'", str4, "2020-11-25T01:49:22.124Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(property13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 1 + "'", int17 == 1);
}
@Test
@Ignore
public void test1992() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1992");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.format.DateTimeFormatter dateTimeFormatter4 = null;
java.lang.String str5 = mutableDateTime3.toString(dateTimeFormatter4);
org.joda.time.ReadablePeriod readablePeriod6 = null;
mutableDateTime3.add(readablePeriod6);
org.joda.time.MutableDateTime.Property property8 = mutableDateTime3.hourOfDay();
org.joda.time.MutableDateTime.Property property9 = mutableDateTime3.dayOfWeek();
int int10 = property9.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime12 = property9.addWrapField(0);
org.joda.time.MutableDateTime mutableDateTime13 = property9.roundHalfEven();
org.joda.time.ReadablePeriod readablePeriod14 = null;
mutableDateTime13.add(readablePeriod14, 40);
java.lang.Object obj17 = null;
org.joda.time.Chronology chronology18 = null;
org.joda.time.MutableDateTime mutableDateTime19 = new org.joda.time.MutableDateTime(obj17, chronology18);
org.joda.time.format.DateTimeFormatter dateTimeFormatter20 = null;
java.lang.String str21 = mutableDateTime19.toString(dateTimeFormatter20);
int int22 = mutableDateTime19.getYearOfCentury();
org.joda.time.Chronology chronology23 = mutableDateTime19.getChronology();
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime13.toMutableDateTime(chronology23);
org.joda.time.MutableDateTime mutableDateTime25 = new org.joda.time.MutableDateTime((long) 100, chronology23);
org.joda.time.MutableDateTime.Property property26 = mutableDateTime25.dayOfYear();
org.joda.time.ReadablePeriod readablePeriod27 = null;
mutableDateTime25.add(readablePeriod27);
java.lang.Object obj29 = null;
org.joda.time.Chronology chronology30 = null;
org.joda.time.MutableDateTime mutableDateTime31 = new org.joda.time.MutableDateTime(obj29, chronology30);
org.joda.time.DateTimeZone dateTimeZone32 = mutableDateTime31.getZone();
int int33 = mutableDateTime31.getSecondOfMinute();
boolean boolean34 = mutableDateTime25.isEqual((org.joda.time.ReadableInstant) mutableDateTime31);
org.joda.time.MutableDateTime.Property property35 = mutableDateTime25.yearOfCentury();
mutableDateTime25.addSeconds((-25005));
// flaky: org.junit.Assert.assertEquals("'" + str5 + "' != '" + "2020-11-25T01:49:22.154Z" + "'", str5, "2020-11-25T01:49:22.154Z");
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertNotNull(property9);
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 7 + "'", int10 == 7);
org.junit.Assert.assertNotNull(mutableDateTime12);
org.junit.Assert.assertNotNull(mutableDateTime13);
// flaky: org.junit.Assert.assertEquals("'" + str21 + "' != '" + "2020-11-25T01:49:22.154Z" + "'", str21, "2020-11-25T01:49:22.154Z");
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 20 + "'", int22 == 20);
org.junit.Assert.assertNotNull(chronology23);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertNotNull(property26);
org.junit.Assert.assertNotNull(dateTimeZone32);
// flaky: org.junit.Assert.assertTrue("'" + int33 + "' != '" + 22 + "'", int33 == 22);
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + false + "'", boolean34 == false);
org.junit.Assert.assertNotNull(property35);
}
@Test
public void test1993() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1993");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) 'a');
mutableDateTime1.setMinuteOfDay((int) (short) 10);
int int4 = mutableDateTime1.getEra();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime1.minuteOfHour();
org.junit.Assert.assertTrue("'" + int4 + "' != '" + 1 + "'", int4 == 1);
org.junit.Assert.assertNotNull(property5);
}
@Test
public void test1994() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1994");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.yearOfCentury();
int int8 = property7.getLeapAmount();
org.joda.time.MutableDateTime mutableDateTime9 = property7.roundFloor();
org.joda.time.MutableDateTime.Property property10 = mutableDateTime9.centuryOfEra();
java.lang.Object obj12 = null;
org.joda.time.Chronology chronology13 = null;
org.joda.time.MutableDateTime mutableDateTime14 = new org.joda.time.MutableDateTime(obj12, chronology13);
org.joda.time.DateTimeZone dateTimeZone15 = mutableDateTime14.getZone();
org.joda.time.MutableDateTime mutableDateTime16 = org.joda.time.MutableDateTime.now(dateTimeZone15);
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime((java.lang.Object) "2020-11-25T01:45:44.742Z", dateTimeZone15);
org.joda.time.ReadablePeriod readablePeriod18 = null;
mutableDateTime17.add(readablePeriod18, 336);
mutableDateTime17.setTime(0L);
mutableDateTime9.setMillis((org.joda.time.ReadableInstant) mutableDateTime17);
org.joda.time.MutableDateTime mutableDateTime24 = mutableDateTime9.toMutableDateTimeISO();
boolean boolean25 = mutableDateTime9.isBeforeNow();
org.joda.time.MutableDateTime.Property property26 = mutableDateTime9.millisOfDay();
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:22.215Z" + "'", str4, "2020-11-25T01:49:22.215Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
org.junit.Assert.assertNotNull(mutableDateTime9);
org.junit.Assert.assertNotNull(property10);
org.junit.Assert.assertNotNull(dateTimeZone15);
org.junit.Assert.assertNotNull(mutableDateTime16);
org.junit.Assert.assertNotNull(mutableDateTime24);
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + true + "'", boolean25 == true);
org.junit.Assert.assertNotNull(property26);
}
@Test
@Ignore
public void test1995() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1995");
java.lang.Object obj1 = null;
org.joda.time.Chronology chronology2 = null;
org.joda.time.MutableDateTime mutableDateTime3 = new org.joda.time.MutableDateTime(obj1, chronology2);
org.joda.time.DateTimeZone dateTimeZone4 = mutableDateTime3.getZone();
mutableDateTime3.setMinuteOfDay(4);
java.lang.Object obj7 = null;
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime(obj7, chronology8);
org.joda.time.format.DateTimeFormatter dateTimeFormatter10 = null;
java.lang.String str11 = mutableDateTime9.toString(dateTimeFormatter10);
int int12 = mutableDateTime9.getYearOfCentury();
org.joda.time.Chronology chronology13 = mutableDateTime9.getChronology();
int int14 = mutableDateTime9.getWeekOfWeekyear();
java.lang.Object obj15 = null;
org.joda.time.Chronology chronology16 = null;
org.joda.time.MutableDateTime mutableDateTime17 = new org.joda.time.MutableDateTime(obj15, chronology16);
org.joda.time.DateTimeZone dateTimeZone18 = mutableDateTime17.getZone();
org.joda.time.DateTime dateTime19 = mutableDateTime9.toDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime20 = mutableDateTime3.toMutableDateTime(dateTimeZone18);
org.joda.time.MutableDateTime mutableDateTime21 = new org.joda.time.MutableDateTime((long) 25, dateTimeZone18);
mutableDateTime21.setTime(52597440L);
mutableDateTime21.setMillis((-26771039L));
org.junit.Assert.assertNotNull(dateTimeZone4);
// flaky: org.junit.Assert.assertEquals("'" + str11 + "' != '" + "2020-11-25T01:49:22.260Z" + "'", str11, "2020-11-25T01:49:22.260Z");
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 20 + "'", int12 == 20);
org.junit.Assert.assertNotNull(chronology13);
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 48 + "'", int14 == 48);
org.junit.Assert.assertNotNull(dateTimeZone18);
org.junit.Assert.assertNotNull(dateTime19);
org.junit.Assert.assertNotNull(mutableDateTime20);
}
@Test
@Ignore
public void test1996() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1996");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.DateTime dateTime2 = mutableDateTime1.toDateTimeISO();
org.joda.time.MutableDateTime mutableDateTime4 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property5 = mutableDateTime4.weekyear();
long long6 = property5.remainder();
org.joda.time.Chronology chronology8 = null;
org.joda.time.MutableDateTime mutableDateTime9 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology8);
mutableDateTime9.setSecondOfMinute((int) '4');
int int12 = mutableDateTime9.getMinuteOfDay();
int int13 = mutableDateTime9.getCenturyOfEra();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
int int17 = mutableDateTime16.getDayOfWeek();
java.lang.Object obj18 = null;
org.joda.time.Chronology chronology19 = null;
org.joda.time.MutableDateTime mutableDateTime20 = new org.joda.time.MutableDateTime(obj18, chronology19);
org.joda.time.DateTimeZone dateTimeZone21 = mutableDateTime20.getZone();
org.joda.time.MutableDateTime mutableDateTime22 = org.joda.time.MutableDateTime.now(dateTimeZone21);
mutableDateTime16.setZoneRetainFields(dateTimeZone21);
org.joda.time.DateTime dateTime24 = mutableDateTime9.toDateTime(dateTimeZone21);
org.joda.time.MutableDateTime mutableDateTime25 = org.joda.time.MutableDateTime.now(dateTimeZone21);
long long26 = property5.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime25);
org.joda.time.MutableDateTime mutableDateTime27 = property5.getMutableDateTime();
org.joda.time.MutableDateTime mutableDateTime29 = property5.add((long) 9);
org.joda.time.MutableDateTime.Property property30 = mutableDateTime29.secondOfMinute();
org.joda.time.DateTimeZone dateTimeZone32 = null;
org.joda.time.MutableDateTime mutableDateTime33 = new org.joda.time.MutableDateTime((long) 100, dateTimeZone32);
boolean boolean34 = mutableDateTime29.isAfter((org.joda.time.ReadableInstant) mutableDateTime33);
boolean boolean36 = mutableDateTime33.isBefore((long) 48);
mutableDateTime1.setDate((org.joda.time.ReadableInstant) mutableDateTime33);
int int38 = mutableDateTime33.getMonthOfYear();
boolean boolean40 = mutableDateTime33.isAfter((long) 21);
org.junit.Assert.assertNotNull(dateTime2);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertTrue("'" + long6 + "' != '" + 259200010L + "'", long6 == 259200010L);
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 19 + "'", int13 == 19);
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 3 + "'", int17 == 3);
org.junit.Assert.assertNotNull(dateTimeZone21);
org.junit.Assert.assertNotNull(mutableDateTime22);
org.junit.Assert.assertNotNull(dateTime24);
org.junit.Assert.assertNotNull(mutableDateTime25);
org.junit.Assert.assertTrue("'" + long26 + "' != '" + (-50L) + "'", long26 == (-50L));
org.junit.Assert.assertNotNull(mutableDateTime27);
org.junit.Assert.assertNotNull(mutableDateTime29);
org.junit.Assert.assertNotNull(property30);
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + true + "'", boolean34 == true);
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + false + "'", boolean36 == false);
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 1 + "'", int38 == 1);
org.junit.Assert.assertTrue("'" + boolean40 + "' != '" + true + "'", boolean40 == true);
}
@Test
public void test1997() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1997");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
org.joda.time.MutableDateTime.Property property3 = mutableDateTime2.dayOfYear();
java.util.GregorianCalendar gregorianCalendar4 = mutableDateTime2.toGregorianCalendar();
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.monthOfYear();
java.util.Locale locale6 = null;
java.lang.String str7 = property5.getAsShortText(locale6);
org.joda.time.MutableDateTime mutableDateTime8 = property5.roundHalfEven();
org.joda.time.MutableDateTime mutableDateTime10 = property5.add(59);
mutableDateTime10.addMonths(59630400);
int int13 = mutableDateTime10.getEra();
org.junit.Assert.assertNotNull(property3);
org.junit.Assert.assertNotNull(gregorianCalendar4);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "Jan" + "'", str7, "Jan");
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertNotNull(mutableDateTime10);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 1 + "'", int13 == 1);
}
@Test
public void test1998() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1998");
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology1);
mutableDateTime2.setSecondOfMinute((int) '4');
org.joda.time.MutableDateTime.Property property5 = mutableDateTime2.minuteOfDay();
org.joda.time.MutableDateTime.Property property6 = mutableDateTime2.year();
java.lang.String str7 = property6.getAsString();
org.joda.time.MutableDateTime mutableDateTime8 = property6.roundHalfFloor();
int int9 = mutableDateTime8.getWeekyear();
mutableDateTime8.addSeconds(6375);
org.junit.Assert.assertNotNull(property5);
org.junit.Assert.assertNotNull(property6);
org.junit.Assert.assertEquals("'" + str7 + "' != '" + "1970" + "'", str7, "1970");
org.junit.Assert.assertNotNull(mutableDateTime8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 1970 + "'", int9 == 1970);
}
@Test
@Ignore
public void test1999() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test1999");
org.joda.time.MutableDateTime mutableDateTime1 = new org.joda.time.MutableDateTime((long) (byte) 10);
org.joda.time.MutableDateTime.Property property2 = mutableDateTime1.weekyear();
long long3 = property2.remainder();
org.joda.time.DateTimeField dateTimeField4 = property2.getField();
org.joda.time.MutableDateTime mutableDateTime6 = property2.add(1L);
mutableDateTime6.setDayOfYear((int) (short) 100);
org.joda.time.Chronology chronology10 = null;
org.joda.time.MutableDateTime mutableDateTime11 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology10);
org.joda.time.MutableDateTime.Property property12 = mutableDateTime11.dayOfYear();
int int13 = property12.get();
java.lang.Object obj14 = null;
org.joda.time.Chronology chronology15 = null;
org.joda.time.MutableDateTime mutableDateTime16 = new org.joda.time.MutableDateTime(obj14, chronology15);
org.joda.time.format.DateTimeFormatter dateTimeFormatter17 = null;
java.lang.String str18 = mutableDateTime16.toString(dateTimeFormatter17);
org.joda.time.ReadablePeriod readablePeriod19 = null;
mutableDateTime16.add(readablePeriod19);
org.joda.time.MutableDateTime.Property property21 = mutableDateTime16.centuryOfEra();
org.joda.time.ReadableInstant readableInstant22 = null;
mutableDateTime16.setDate(readableInstant22);
org.joda.time.MutableDateTime mutableDateTime24 = new org.joda.time.MutableDateTime();
org.joda.time.MutableDateTime.Property property25 = mutableDateTime24.dayOfMonth();
int int26 = mutableDateTime24.getCenturyOfEra();
org.joda.time.Chronology chronology28 = null;
org.joda.time.MutableDateTime mutableDateTime29 = new org.joda.time.MutableDateTime((long) (byte) 1, chronology28);
mutableDateTime29.setSecondOfMinute((int) '4');
int int32 = mutableDateTime29.getMinuteOfDay();
int int33 = mutableDateTime29.getCenturyOfEra();
java.lang.Object obj34 = null;
org.joda.time.Chronology chronology35 = null;
org.joda.time.MutableDateTime mutableDateTime36 = new org.joda.time.MutableDateTime(obj34, chronology35);
int int37 = mutableDateTime36.getDayOfWeek();
java.lang.Object obj38 = null;
org.joda.time.Chronology chronology39 = null;
org.joda.time.MutableDateTime mutableDateTime40 = new org.joda.time.MutableDateTime(obj38, chronology39);
org.joda.time.DateTimeZone dateTimeZone41 = mutableDateTime40.getZone();
org.joda.time.MutableDateTime mutableDateTime42 = org.joda.time.MutableDateTime.now(dateTimeZone41);
mutableDateTime36.setZoneRetainFields(dateTimeZone41);
org.joda.time.DateTime dateTime44 = mutableDateTime29.toDateTime(dateTimeZone41);
mutableDateTime24.setZoneRetainFields(dateTimeZone41);
mutableDateTime16.setZone(dateTimeZone41);
org.joda.time.MutableDateTime mutableDateTime47 = org.joda.time.MutableDateTime.now(dateTimeZone41);
long long48 = property12.getDifferenceAsLong((org.joda.time.ReadableInstant) mutableDateTime47);
org.joda.time.MutableDateTime mutableDateTime49 = property12.roundCeiling();
int int50 = mutableDateTime6.compareTo((org.joda.time.ReadableInstant) mutableDateTime49);
mutableDateTime49.setYear(2);
java.util.GregorianCalendar gregorianCalendar53 = mutableDateTime49.toGregorianCalendar();
mutableDateTime49.setYear(6386);
org.joda.time.DateTime dateTime56 = mutableDateTime49.toDateTimeISO();
org.joda.time.MutableDateTime.Property property57 = mutableDateTime49.yearOfCentury();
org.joda.time.MutableDateTime.Property property58 = mutableDateTime49.minuteOfHour();
org.junit.Assert.assertNotNull(property2);
org.junit.Assert.assertTrue("'" + long3 + "' != '" + 259200010L + "'", long3 == 259200010L);
org.junit.Assert.assertNotNull(dateTimeField4);
org.junit.Assert.assertNotNull(mutableDateTime6);
org.junit.Assert.assertNotNull(property12);
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 1 + "'", int13 == 1);
// flaky: org.junit.Assert.assertEquals("'" + str18 + "' != '" + "2020-11-25T01:49:22.471Z" + "'", str18, "2020-11-25T01:49:22.471Z");
org.junit.Assert.assertNotNull(property21);
org.junit.Assert.assertNotNull(property25);
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 20 + "'", int26 == 20);
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 0 + "'", int32 == 0);
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 19 + "'", int33 == 19);
org.junit.Assert.assertTrue("'" + int37 + "' != '" + 3 + "'", int37 == 3);
org.junit.Assert.assertNotNull(dateTimeZone41);
org.junit.Assert.assertNotNull(mutableDateTime42);
org.junit.Assert.assertNotNull(dateTime44);
org.junit.Assert.assertNotNull(mutableDateTime47);
org.junit.Assert.assertTrue("'" + long48 + "' != '" + (-18591L) + "'", long48 == (-18591L));
org.junit.Assert.assertNotNull(mutableDateTime49);
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 1 + "'", int50 == 1);
org.junit.Assert.assertNotNull(gregorianCalendar53);
org.junit.Assert.assertNotNull(dateTime56);
org.junit.Assert.assertNotNull(property57);
org.junit.Assert.assertNotNull(property58);
}
@Test
public void test2000() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest3.test2000");
java.lang.Object obj0 = null;
org.joda.time.Chronology chronology1 = null;
org.joda.time.MutableDateTime mutableDateTime2 = new org.joda.time.MutableDateTime(obj0, chronology1);
org.joda.time.format.DateTimeFormatter dateTimeFormatter3 = null;
java.lang.String str4 = mutableDateTime2.toString(dateTimeFormatter3);
org.joda.time.ReadablePeriod readablePeriod5 = null;
mutableDateTime2.add(readablePeriod5);
org.joda.time.MutableDateTime.Property property7 = mutableDateTime2.hourOfDay();
org.joda.time.MutableDateTime.Property property8 = mutableDateTime2.dayOfWeek();
int int9 = property8.getMaximumValueOverall();
org.joda.time.MutableDateTime mutableDateTime11 = property8.addWrapField(0);
org.joda.time.ReadableInstant readableInstant12 = null;
mutableDateTime11.setTime(readableInstant12);
// The following exception was thrown during execution in test generation
try {
java.lang.String str15 = mutableDateTime11.toString("2020-11-25T01:48:48.222Z");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Illegal pattern component: T");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// flaky: org.junit.Assert.assertEquals("'" + str4 + "' != '" + "2020-11-25T01:49:22.544Z" + "'", str4, "2020-11-25T01:49:22.544Z");
org.junit.Assert.assertNotNull(property7);
org.junit.Assert.assertNotNull(property8);
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 7 + "'", int9 == 7);
org.junit.Assert.assertNotNull(mutableDateTime11);
}
}
| true
|
c26fd54146756cfe6944dfe9839d827ea0c29906
|
Java
|
Piratheepan/MockitoBasic
|
/src/test/java/com/example/Mockito/SomeBusinessMockAnnotationTest.java
|
UTF-8
| 764
| 2.125
| 2
|
[] |
no_license
|
package com.example.Mockito;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
//import org.mockito.junit.MockitoJUnitRunner;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class SomeBusinessMockAnnotationTest {
@Mock
DataService dataServiceMock;
@InjectMocks
SomeBusinessmpl businessImpl;
@Test
public void test() {
//MockitoAnnotations.initMocks(this);
when(dataServiceMock.retrieveAllData()).thenReturn(new int[] {24,15,4});
int result=businessImpl.findTheGreatestFormAllData();
assertEquals(24,result);
}
}
| true
|
6c06e7b85486dbb99a38965e5ee8e3437ebc3788
|
Java
|
A-E-3/ae3.sdk
|
/java/ru/myx/util/FifoQueueServiceMultithreadSwitching.java
|
UTF-8
| 6,697
| 2.71875
| 3
|
[] |
no_license
|
package ru.myx.util;
import ru.myx.ae3.Engine;
import ru.myx.ae3.help.Convert;
/**
*
* @author myx
*
* @param <T>
*/
public class FifoQueueServiceMultithreadSwitching<T> implements BasicQueue<T> {
private boolean pendingChanges = false;
private final FifoQueueMultithreadEnqueue<T>[] queue = Convert.Array.toAny(new FifoQueueMultithreadEnqueue[]{
new FifoQueueMultithreadEnqueue<T>(), new FifoQueueMultithreadEnqueue<T>()
});
private volatile int queueIndex = 0;
private final Object notifyTarget;
private boolean switchPlanesWaitCancel = false;
/**
* 'notifyTarget == this
*/
public FifoQueueServiceMultithreadSwitching() {
this.notifyTarget = this;
}
/**
*
* @param notifyTarget
*/
public FifoQueueServiceMultithreadSwitching(final Object notifyTarget) {
this.notifyTarget = notifyTarget == null
? this
: notifyTarget;
}
@Override
public boolean hasNext() {
return this.queue[this.queueIndex ^ 0x01].hasNext();
}
/**
* returns inactive queue
*
* @return
*/
public final FifoQueueMultithreadEnqueue<T> inactiveQueue() {
return this.queue[this.queueIndex ^ 0x01];
}
@Override
public boolean iterateAll(final BasicQueue.IterationAllCallback<T> callback) {
return this.queue[0].iterateAll(callback) && this.queue[1].iterateAll(callback);
}
@Override
public boolean offerFirst(final T element) {
this.queue[this.queueIndex].offerFirst(element);
if (this.pendingChanges) {
return false;
}
synchronized (this.notifyTarget) {
if (!this.pendingChanges) {
this.pendingChanges = true;
this.notifyTarget.notifyAll();
return true;
}
}
return false;
}
/**
* Synchronously notifies 'notifyTarget' when 'pendingChanges' (isEmpty())
* state changing.
*
* When there is no 'notifyTarget' (equals NULL) no synchronization is
* performed and no-one is notified.
*
* @param element
* @return is first?
*/
@Override
public final boolean offerLast(final T element) {
this.queue[this.queueIndex].offerLast(element);
if (this.pendingChanges) {
return false;
}
synchronized (this.notifyTarget) {
if (!this.pendingChanges) {
this.pendingChanges = true;
this.notifyTarget.notifyAll();
return true;
}
}
return false;
}
@Override
public T pollFirst() {
{
final FifoQueueMultithreadEnqueue<T> queue = this.queue[this.queueIndex ^ 0x01];
final T next = queue.pollFirst();
if (next != null) {
return next;
}
}
{
final FifoQueueMultithreadEnqueue<T> queue = this.switchPlanes();
if (queue == null) {
return null;
}
return queue.pollFirst();
}
}
/**
* approximate, maybe slow, for messages, etc
*
* @return
*/
@Override
public int size() {
return this.queue[0].size() + this.queue[1].size();
}
/**
* Switches planes, the one for 'enqueue' becomes one for 'read' and the one
* for 'read' becomes one for 'enqueue'
*
* @return NULL when there is nothing queued.
*/
public final FifoQueueMultithreadEnqueue<T> switchPlanes() {
synchronized (this.notifyTarget) {
/**
* reset cancel first in any case
*/
if (this.switchPlanesWaitCancel) {
this.switchPlanesWaitCancel = false;
return null;
}
if (!this.pendingChanges) {
return null;
}
this.pendingChanges = false;
final int queueIndex = this.queueIndex;
this.queueIndex = queueIndex ^ 0x01;
return this.queue[queueIndex];
}
}
/**
* You must synchronize with 'notifyTarget' when checking this method before
* waiting for notification.
*
* @return
*/
public boolean switchPlanesIsReady() {
return this.pendingChanges;
}
/**
* Switches planes, the one for 'enqueue' becomes one for 'read' and the one
* for 'read' becomes one for 'enqueue'
*
* NOTE: This method is 'spurious wakeup'-safe!
*
* @param timeout
* use 0 for indefinite timeout
* @return NULL when there is nothing queued and timeout expired.
* @throws InterruptedException
*/
public final FifoQueueMultithreadEnqueue<T> switchPlanesWait(final long timeout) throws InterruptedException {
synchronized (this.notifyTarget) {
/**
* reset cancel first in any case
*/
if (this.switchPlanesWaitCancel) {
this.switchPlanesWaitCancel = false;
return null;
}
waitChanges : if (!this.pendingChanges) {
final long expires = timeout == 0
? 0
: Engine.fastTime() + timeout;
for (long left = timeout;;) {
this.notifyTarget.wait(left);
/**
* reset cancel first in any case
*/
if (this.switchPlanesWaitCancel) {
this.switchPlanesWaitCancel = false;
return null;
}
if (this.pendingChanges) {
break waitChanges;
}
if (timeout == 0) {
continue;
}
left = expires - Engine.fastTime();
if (left <= 0) {
return null;
}
}
}
this.pendingChanges = false;
final int queueIndex = this.queueIndex;
this.queueIndex = queueIndex ^ 0x01;
return this.queue[queueIndex];
}
}
/**
* @param timeout
* @return true when new data ready, false when time expired
* @throws InterruptedException
*/
public final boolean switchPlanesWaitReady(final long timeout) throws InterruptedException {
/**
* without a lock
*/
if (this.pendingChanges || this.switchPlanesWaitCancel) {
return true;
}
synchronized (this.notifyTarget) {
/**
* do not reset 'cancel', will be used in switchPlanesXXX methods
*/
if (this.pendingChanges || this.switchPlanesWaitCancel) {
return true;
}
if (timeout == 0) {
for (;;) {
//
this.notifyTarget.wait(0);
/**
* do not reset 'cancel', will be used in switchPlanesXXX
* methods
*/
if (this.pendingChanges || this.switchPlanesWaitCancel) {
return true;
}
}
}
assert timeout > 0 : "Timeout value must not be negative!";
final long expires = Engine.fastTime() + timeout;
for (//
long left = timeout; //
left > 0; //
left = expires - Engine.fastTime()) {
//
this.notifyTarget.wait(left);
/**
* do not reset 'cancel', will be used in switchPlanesXXX
* methods
*/
if (this.pendingChanges || this.switchPlanesWaitCancel) {
return true;
}
}
return false;
}
}
/**
* Cancels 'switchPlanesWait' if any, or the next one!
*/
public final void switchQueueWaitCancel() {
if (this.switchPlanesWaitCancel) {
return;
}
synchronized (this.notifyTarget) {
if (!this.switchPlanesWaitCancel) {
this.switchPlanesWaitCancel = true;
this.notifyTarget.notifyAll();
}
}
}
}
| true
|
1180048cf3414c255078a9bbc19a2622a480d356
|
Java
|
spelldone/Simbirsoft
|
/src/Main.java
|
UTF-8
| 1,478
| 3.078125
| 3
|
[] |
no_license
|
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
try {
char deliters[] = {'"', '[', ']', '«', '»', ':', ';', '.', ',', '!', '?',
'(', ')', '\n', '\t', '\r', '$', '%', '*', '+', '–', '—', '=', '/', '&'};
Scanner scanner = new Scanner(System.in);
System.out.println("Input url:");
String link = scanner.nextLine();
Document doc = Jsoup.connect(link).get();
System.out.println("Input new file's name:");
String fileName = scanner.nextLine();
File file = new File(fileName + ".html");
while (file.exists()) {
System.out.println("Choose another file's name:");
String newFileName = scanner.nextLine();
file.renameTo(new File(newFileName + ".html"));
}
FileWriter fileWriter = new FileWriter(file);
fileWriter.write(doc.toString());
fileWriter.close();
String text = doc.body().text();
WordsStatistic wordsStatistic=new WordsStatistic();
wordsStatistic=wordsStatistic.getStatistic(text,deliters);
System.out.println(wordsStatistic.toString());
}catch (IllegalArgumentException e){
System.out.println("Wrong url,check it");
}
}
}
| true
|
69ab6882a9f88610936577d88e67ec58f4c88802
|
Java
|
rajat965ng/inventory
|
/product/src/main/java/com/product/ProductConfig.java
|
UTF-8
| 302
| 1.664063
| 2
|
[] |
no_license
|
package com.product;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Controller;
import org.springframework.web.client.RestTemplate;
@Controller
public class ProductConfig {
@Bean
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
| true
|
d40ce9b0682320df30e0bd64caa9d90fbd622f35
|
Java
|
mhdr/SobhanAzan
|
/Azan/src/com/nasimeshomal/Main.java
|
UTF-8
| 923
| 2.109375
| 2
|
[] |
no_license
|
package com.nasimeshomal;
import javazoom.jl.decoder.JavaLayerException;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.io.IOException;
import java.sql.SQLException;
import java.text.ParseException;
public class Main {
public static void main(String[] args) throws SchedulerException, SQLException, IOException, JavaLayerException, ClassNotFoundException, ParseException {
JobDetail job= JobBuilder.newJob(MainJob.class).withIdentity("Main","Main").build();
SimpleTrigger trigger= TriggerBuilder.newTrigger()
.withIdentity("Main","Main")
.startNow()
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInHours(1).repeatForever())
.build();
Scheduler scheduler=new StdSchedulerFactory().getScheduler();
scheduler.start();
scheduler.scheduleJob(job,trigger);
}
}
| true
|
570729e8d0588b7e640dbe6cc3b7aa1727bdaf86
|
Java
|
progroom/IBM-Vertx-Sep-20-b2
|
/vertx-fp/src/main/java/com/ibm/fp/lambda/rules/LambdaBasicRules.java
|
UTF-8
| 676
| 3.4375
| 3
|
[] |
no_license
|
package com.ibm.fp.lambda.rules;
@FunctionalInterface
interface Greeter {
//abstract method
void sayGreet();
//
// void sayHello();
public default void saySomething(){
System.out.println("Default methods");
}
//static methods
public static void doSomething(){
System.out.println("Static methods");
}
}
public class LambdaBasicRules {
public static void main(String[] args) {
Greeter greeter = null;
//lambda syntax
greeter = () -> {
System.out.println("Greeter-lambda");
};
greeter.sayGreet();
greeter.saySomething();
Greeter.doSomething();
}
}
| true
|