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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
84550165e0a1b798e0c305f7aa827b1b629a8748 | Java | alexshi1991/leetcode-practice | /LC077.java | UTF-8 | 795 | 3.5 | 4 | [] | no_license | /*
* Problem: https://leetcode.com/problems/combinations/
*
* Idea: backtracking
*/
public class Solution {
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> result = new ArrayList<>();
if (k < 1 || n < 1) return result;
findCombination(new ArrayList<Integer>(), result, n, k, 1);
return result;
}
private void findCombination(List<Integer> curr, List<List<Integer>> result, int n, int k, int start) {
if (curr.size() == k) {
result.add(new ArrayList<Integer>(curr));
return;
}
for (int i = start; i <= n; i++) {
curr.add(i);
findCombination(curr, result, n, k, i+1);
curr.remove(curr.size() - 1); // backtracking
}
}
}
| true |
b40a11d42a2f5d3f78ddbec5658844312c1c6afc | Java | vespa-engine/vespa | /config-model/src/test/java/com/yahoo/schema/derived/ExportingTestCase.java | UTF-8 | 5,762 | 1.554688 | 2 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.schema.derived;
import com.yahoo.config.model.deploy.TestProperties;
import com.yahoo.schema.ApplicationBuilder;
import com.yahoo.schema.parser.ParseException;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* Tests exporting
*
* @author bratseth
*/
public class ExportingTestCase extends AbstractExportingTestCase {
@Test
void testIndexInfoLowerCase() throws IOException, ParseException {
assertCorrectDeriving("indexinfo_lowercase");
}
@Test
void testPositionArray() throws IOException, ParseException {
assertCorrectDeriving("position_array",
new TestProperties().setUseV8GeoPositions(true));
}
@Test
void testPositionAttribute() throws IOException, ParseException {
assertCorrectDeriving("position_attribute",
new TestProperties().setUseV8GeoPositions(true));
}
@Test
void testPositionExtra() throws IOException, ParseException {
assertCorrectDeriving("position_extra",
new TestProperties().setUseV8GeoPositions(true));
}
@Test
void testPositionNoSummary() throws IOException, ParseException {
assertCorrectDeriving("position_nosummary",
new TestProperties().setUseV8GeoPositions(true));
}
@Test
void testPositionSummary() throws IOException, ParseException {
assertCorrectDeriving("position_summary",
new TestProperties().setUseV8GeoPositions(true));
}
@Test
void testUriArray() throws IOException, ParseException {
assertCorrectDeriving("uri_array");
}
@Test
void testUriWSet() throws IOException, ParseException {
assertCorrectDeriving("uri_wset");
}
@Test
void testMusic() throws IOException, ParseException {
assertCorrectDeriving("music");
}
@Test
void testComplexPhysicalExporting() throws IOException, ParseException {
assertCorrectDeriving("complex");
}
@Test
void testAttributePrefetch() throws IOException, ParseException {
assertCorrectDeriving("attributeprefetch");
}
@Test
void testAdvancedIL() throws IOException, ParseException {
assertCorrectDeriving("advanced");
}
@Test
void testEmptyDefaultIndex() throws IOException, ParseException {
assertCorrectDeriving("emptydefault");
}
@Test
void testIndexSwitches() throws IOException, ParseException {
assertCorrectDeriving("indexswitches");
}
@Test
void testRankTypes() throws IOException, ParseException {
assertCorrectDeriving("ranktypes");
}
@Test
void testAttributeRank() throws IOException, ParseException {
assertCorrectDeriving("attributerank");
}
@Test
void testNewRank() throws IOException, ParseException {
assertCorrectDeriving("newrank");
}
@Test
void testRankingExpression() throws IOException, ParseException {
assertCorrectDeriving("rankingexpression");
}
@Test
void testAvoidRenamingRankingExpression() throws IOException, ParseException {
assertCorrectDeriving("renamedfeatures", "foo",
new TestProperties(),
new TestableDeployLogger());
}
@Test
void testMlr() throws IOException, ParseException {
assertCorrectDeriving("mlr");
}
@Test
void testMusic3() throws IOException, ParseException {
assertCorrectDeriving("music3");
}
@Test
void testIndexSchema() throws IOException, ParseException {
assertCorrectDeriving("indexschema");
}
@Test
void testIndexinfoFieldsets() throws IOException, ParseException {
assertCorrectDeriving("indexinfo_fieldsets");
}
@Test
void testStreamingJuniper() throws IOException, ParseException {
assertCorrectDeriving("streamingjuniper");
}
@Test
void testPredicateAttribute() throws IOException, ParseException {
assertCorrectDeriving("predicate_attribute");
}
@Test
void testTensor() throws IOException, ParseException {
assertCorrectDeriving("tensor");
}
@Test
void testTensor2() throws IOException, ParseException {
String dir = "src/test/derived/tensor2/";
ApplicationBuilder builder = new ApplicationBuilder();
builder.addSchemaFile(dir + "first.sd");
builder.addSchemaFile(dir + "second.sd");
builder.build(true);
derive("tensor2", builder, builder.getSchema("second"));
assertCorrectConfigFiles("tensor2");
}
@Test
void testHnswIndex() throws IOException, ParseException {
assertCorrectDeriving("hnsw_index");
}
@Test
void testRankProfileInheritance() throws IOException, ParseException {
assertCorrectDeriving("rankprofileinheritance", "child", new TestableDeployLogger());
}
@Test
void testLanguage() throws IOException, ParseException {
TestableDeployLogger logger = new TestableDeployLogger();
assertCorrectDeriving("language", logger);
assertEquals(0, logger.warnings.size());
}
@Test
void testRankProfileModularity() throws IOException, ParseException {
assertCorrectDeriving("rankprofilemodularity");
}
@Test
void testStructAndFieldSet() throws IOException, ParseException {
assertCorrectDeriving("structandfieldset");
}
@Test
void testBoldingAndDynamicSummary() throws IOException, ParseException {
assertCorrectDeriving("bolding_dynamic_summary");
}
}
| true |
0c735f2ad6c69e8522ca72a1cda0ac6ed28e34f1 | Java | ningcs/reservemq | /reserve-order-provider-service/src/main/java/com/example/demo/dao/OrderDao.java | UTF-8 | 195 | 1.625 | 2 | [] | no_license | package com.example.demo.dao;
import com.example.demo.dto.OrderInfo;
/**
* Created by ningcs on 2017/11/20.
*/
public interface OrderDao {
public void addOrder(OrderInfo orderInfo);
}
| true |
15884500b781efc620f90b9c97c96704c7ccd442 | Java | foolishboyGitHub/AikangHeath | /SpringBootDemo/src/main/java/com/aikang/Bean/SCLoginSuc.java | UTF-8 | 342 | 1.632813 | 2 | [] | no_license | package com.aikang.Bean;
import java.util.List;
public class SCLoginSuc {
private User user;
private List<PerUrl> pers;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public List<PerUrl> getPers() {
return pers;
}
public void setPers(List<PerUrl> pers) {
this.pers = pers;
}
}
| true |
697f23ce1abfd24e887fbeac320b8e463fcf60e9 | Java | Clay-Ferguson/quantizr | /src/main/java/quanta/service/imports/ImportService.java | UTF-8 | 4,333 | 2.40625 | 2 | [
"MIT"
] | permissive | package quanta.service.imports;
import java.io.BufferedInputStream;
import org.apache.commons.io.input.AutoCloseInputStream;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import quanta.config.ServiceBase;
import quanta.mongo.MongoSession;
import quanta.mongo.model.SubNode;
import quanta.util.ExUtil;
import quanta.util.StreamUtil;
import quanta.util.ThreadLocals;
@Component
public class ImportService extends ServiceBase {
private static Logger log = LoggerFactory.getLogger(ImportService.class);
public ResponseEntity<?> streamImport(MongoSession ms, String nodeId, MultipartFile[] uploadFiles) {
if (nodeId == null) {
throw ExUtil.wrapEx("target nodeId not provided");
}
ms = ThreadLocals.ensure(ms);
SubNode node = read.getNode(ms, nodeId);
if (node == null) {
throw ExUtil.wrapEx("Node not found.");
}
auth.ownerAuth(ms, node);
// This is critical to be correct so we run the actual query based determination of 'hasChildren'
boolean hasChildren = read.directChildrenExist(ms, node.getPath());
if (hasChildren) {
throw ExUtil.wrapEx("You can only import into an empty node. There are direct children under path(a): "
+ node.getPath());
}
/*
* It's important to be sure there are absolutely no orphans at any level under this branch of the
* tree, so even though the check above told us there are no direct children we still need to run
* this recursive delete.
*/
delete.deleteUnderPath(ms, node.getPath());
if (uploadFiles.length != 1) {
throw ExUtil.wrapEx("Multiple file import not allowed");
}
MultipartFile uploadFile = uploadFiles[0];
String fileName = uploadFile.getOriginalFilename();
if (!StringUtils.isEmpty(fileName)) {
log.debug("Uploading file: " + fileName);
BufferedInputStream in = null;
try {
// Import ZIP files
if (fileName.toLowerCase().endsWith(".zip")) {
log.debug("Import ZIP to Node: " + node.getPath());
in = new BufferedInputStream(new AutoCloseInputStream(uploadFile.getInputStream()));
ImportZipService impSvc = (ImportZipService) context.getBean(ImportZipService.class);
impSvc.importFromStream(ms, in, node, false);
node.setHasChildren(true);
update.saveSession(ms);
}
// Import TAR files (non GZipped)
else if (fileName.toLowerCase().endsWith(".tar")) {
log.debug("Import TAR to Node: " + node.getPath());
in = new BufferedInputStream(new AutoCloseInputStream(uploadFile.getInputStream()));
ImportTarService impSvc = (ImportTarService) context.getBean(ImportTarService.class);
impSvc.importFromStream(ms, in, node, false);
node.setHasChildren(true);
update.saveSession(ms);
}
// Import TAR.GZ (GZipped TAR)
else if (fileName.toLowerCase().endsWith(".tar.gz")) {
log.debug("Import TAR.GZ to Node: " + node.getPath());
in = new BufferedInputStream(new AutoCloseInputStream(uploadFile.getInputStream()));
ImportTarService impSvc = (ImportTarService) context.getBean(ImportTarService.class);
impSvc.importFromZippedStream(ms, in, node, false);
node.setHasChildren(true);
update.saveSession(ms);
} else {
throw ExUtil.wrapEx("Only ZIP, TAR, TAR.GZ files are supported for importing.");
}
} catch (Exception ex) {
throw ExUtil.wrapEx(ex);
} finally {
StreamUtil.close(in);
}
}
return new ResponseEntity<>(HttpStatus.OK);
}
}
| true |
0a322269668b852dd621f9fb4f625d9115814123 | Java | franciscommcunha/Distributed-Systems-2018 | /AfternoonRacesConcurrent/Monitors/Paddock.java | UTF-8 | 8,296 | 2.703125 | 3 | [] | no_license | package AfternoonRacesConcurrent.Monitors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import AfternoonRacesConcurrent.Constants.Constants;
import AfternoonRacesConcurrent.Entities.Broker.BrokerInterfaces.IBroker_Paddock;
import AfternoonRacesConcurrent.Entities.Horses.HorsesInterfaces.IHorse_Paddock;
import AfternoonRacesConcurrent.Entities.Spectators.SpectatorsInterfaces.ISpectator_Paddock;
import static AfternoonRacesConcurrent.Entities.Horses.HorsesEnum.HorseStates.*;
import static AfternoonRacesConcurrent.Entities.Broker.BrokerEnum.BrokerStates.*;
import static AfternoonRacesConcurrent.Entities.Spectators.SpectatorsEnum.SpectatorStates.*;
import static AfternoonRacesConcurrent.Constants.Constants.*;
public class Paddock implements IHorse_Paddock, ISpectator_Paddock, IBroker_Paddock {
private final ReentrantLock rl;
private final Condition horse_condition;
private final Condition spectator_condition;
private final Condition broker_condition;
private int paddock_horses = 0; // number of horses at the paddock
private int paddock_spectators = 0; // // number of spectators at the paddock
private boolean horses_at_paddock= false; // reset done at proceedToStartLine
private boolean spectators_at_paddock = false; // reset done at goCheckHorses
private boolean horses_at_start_line = false; // reset done at goCheckHorses
private boolean last_horse_leaving_paddock = false; // reset done at proceedToStartLine
private boolean go_broker = false; // reset done at goCheckHorses
public Paddock()
{
rl = new ReentrantLock(true);
horse_condition = rl.newCondition();
spectator_condition = rl.newCondition();
broker_condition = rl.newCondition();
}
@Override
public void summonHorsesToPaddock( GeneralRepository general_repository) {
// broker sends the horses to the paddock and blocks until they do not reach there
// OPENING_THE_EVENT
rl.lock();
try {
System.out.println("summonHorsesToPaddock() - PADDOCK");
try {
while(!go_broker) { // broker is blocked until all the horses are at the paddock
broker_condition.await();
}
} catch (Exception e) {}
general_repository.setBrokerState(ANNOUNCING_NEXT_RACE);
general_repository.writeStatB(ANNOUNCING_NEXT_RACE);
go_broker = false;
}
finally {
rl.unlock();
}
// ANNOUCING_NEXT_RACE
}
@Override
public void proceedToPaddock(int horse_id, GeneralRepository general_repository)
{
// AT_THE_STABLE
rl.lock();
try {
general_repository.writeHorseSt(AT_THE_PADDOCK);
paddock_horses++; // increases the number of horses at the paddock
//System.out.println("AT_THE_PADDOCK, HORSE " + horse_id);
if(paddock_horses == NUM_HORSES) { // checks if all horses are at the paddock
horses_at_paddock = true;// signal -> waitForNextRace()
spectator_condition.signalAll(); // wakes up spectators blocked at waitForNextRace
}
try {
while(! spectators_at_paddock) { // waits until spectators reaches the paddock -> true on waitForNextRace
horse_condition.await(); // horses will be awake at goCheckHorses
}
general_repository.setHorseState(AT_THE_PADDOCK, horse_id);
general_repository.writeHorseSt(AT_THE_PADDOCK);
}catch(Exception e) {}
horses_at_start_line = false;
}
finally {
rl.unlock();
}
// AT_THE_PADDOCK
}
@Override
public void waitForNextRace(int spec_id, GeneralRepository general_repository)
{
// the speectators are blocked until all the horses are at the paddock
// when horses are at the paddock, they can go check them
// OUTSIDE_HIPPIC_CENTER
System.out.println(horses_at_paddock);
rl.lock();
try {
System.out.println("> waitingForNextRace SPECTATOR " + spec_id);
try {
while (!horses_at_paddock) { // waits until all horses are at the paddock -> true em proceedToPaddock
spectator_condition.await(); // will be awaken at proceedToPaddock
}
} catch (Exception e) {}
spectators_at_paddock = true; // signal -> proceedToPaddock()
general_repository.setSpectatorState(WAITING_FOR_A_RACE_TO_START, spec_id);
general_repository.writeSpecSt(WAITING_FOR_A_RACE_TO_START);
horse_condition.signalAll(); // unblock horses blocked at proceedToPaddock
} finally {
rl.unlock();
}
// WAITING_FOR_A_RACE_TO_START
}
@Override
public void goCheckHorses(int spec_id, GeneralRepository general_repository) {
// the spectators go check the horses, so they can make a decision in which horse they will bet
// after all the spectators are at the paddock, the broker can procced to accept bets and horses can go to the star line
// WAITING_FOR_NEXT_RACE
rl.lock();
try {
paddock_spectators++; // increases the number of spectators at the paddock
System.out.println("> goCheckHorses, SPECTATOR " + spec_id);
general_repository.writeSpecSt(APPRAISING_THE_HORSES);
if (paddock_spectators == NUM_SPECTATORS) {
go_broker = true; // changes the value of the flag, broker can now unblock
horses_at_start_line = true; // changes the value of the flag, horses can unblock and go to the star line
broker_condition.signal();
horse_condition.signalAll();
}
try {
while(! last_horse_leaving_paddock) {
spectator_condition.await();
}
} catch (Exception e) {}
paddock_spectators--; // decreases the number of spectators at the paddock
if(paddock_spectators == 0) {
spectators_at_paddock = false;
last_horse_leaving_paddock = false;
}
general_repository.setSpectatorState(APPRAISING_THE_HORSES, spec_id);
//System.out.println("APRAISING_THE_HORSES, SPECTATOR " + spec_id);
}
finally {
rl.unlock();
}
// APRAISING_THE_HORSES
}
@Override
public void proceedToStartLine(int horse_id, GeneralRepository general_repository) {
// horses are blocked until all the spectators dont reach the paddock
// after they reach there, they can go to the start line
// AT_THE_PADDOCK
rl.lock();
try {
paddock_horses--; // decreases the number of horses at the paddock
general_repository.writeHorseSt(AT_THE_PADDOCK);
//System.out.println("AT_THE_START_LINE, HORSE " + horse_id);
if (paddock_horses == 0 ) { // horses go to the start line and wake up spectators to go betting
spectator_condition.signalAll(); // wakes up spectators blocked at goCheckHorses
}
try {
while(! horses_at_start_line) { // horses are blocked waiting for spectators
horse_condition.await();
}
} catch (Exception e) {}
if(paddock_horses == 0){
last_horse_leaving_paddock = true; // changes the value of the flach
horses_at_paddock = false; // reset
}
general_repository.setHorseState(AT_THE_START_LINE, horse_id);
general_repository.writeHorseSt(AT_THE_START_LINE);
spectator_condition.signalAll(); // wakes up spectators blocked at goCheckHorses
}
finally {
rl.unlock();
}
// AT_THE_START_LINE
}
} | true |
4d1934a25d9d16c5349c65456088446b161c202b | Java | dhruva7676/MusicStore | /src/java/com/michalgoly/data/CustomerDB.java | UTF-8 | 2,464 | 3.296875 | 3 | [
"MIT"
] | permissive | package com.michalgoly.data;
import com.michalgoly.business.Customer;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.TypedQuery;
/**
* This class can manipulate customer objects in the database
*
* @author Michal Goly
*/
public class CustomerDB {
/**
* Retrieves a single customer from the database using provided email address.
*
* @param email The email address of a customer
* @return Either appropriate Customer object, or null if he doesn't exist
*/
public static Customer selectByEmail(String email) {
EntityManager em = DBUtil.getEmFactory().createEntityManager();
String queryString = "SELECT c FROM Customer c "
+ "WHERE c.email = :email";
TypedQuery<Customer> query = em.createQuery(queryString, Customer.class);
query.setParameter("email", email);
Customer customer = null;
try {
customer = query.getSingleResult();
} catch (Exception e) {
System.err.println(e);
} finally {
em.close();
}
return customer;
}
/**
* @param customer The customer to be inserted into a database
*/
public static void insert(Customer customer) {
EntityManager em = DBUtil.getEmFactory().createEntityManager();
EntityTransaction transaction = em.getTransaction();
try {
transaction.begin();
em.persist(customer);
transaction.commit();
} catch (Exception e) {
System.out.println(e);
transaction.rollback();
} finally {
em.close();
}
}
/**
* @param customer The customer to be updated
*/
public static void update(Customer customer) {
EntityManager em = DBUtil.getEmFactory().createEntityManager();
EntityTransaction transaction = em.getTransaction();
try {
transaction.begin();
em.merge(customer);
transaction.commit();
} catch (Exception e) {
System.out.println(e);
transaction.rollback();
} finally {
em.close();
}
}
/**
* Checks if customer with specified email exists within the database
*
* @param email The email address to be checked
* @return True if a customer with given email exists, false otherwise
*/
public static boolean emailExists(String email) {
return selectByEmail(email) != null;
}
}
| true |
2a466ada3fd636a42700922cef2122ef790b6419 | Java | ttomasini/TUM | /2016/android/Geofence/app/src/test/java/com/esrlabs/geofence/GeofenceAppTest.java | UTF-8 | 4,387 | 2.109375 | 2 | [] | no_license | package com.esrlabs.geofence;
import android.content.ComponentName;
import android.content.Context;
import android.location.Location;
import android.location.LocationManager;
import android.os.IBinder;
import android.os.RemoteException;
import com.esrlabs.headunitinterface.HeadUnit;
import junit.framework.TestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricGradleTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowLocationManager;
import java.util.concurrent.atomic.AtomicBoolean;
import esrlabs.com.geofence.BuildConfig;
import static android.location.LocationManager.NETWORK_PROVIDER;
import static com.esrlabs.geofence.CircleGeofenceTest.someCircleGeofence;
import static com.esrlabs.geofence.Utils.location;
import static org.robolectric.Shadows.shadowOf;
@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class, emulateSdk = 17)
public class GeofenceAppTest extends TestCase {
private final LocationManager locationManager = (LocationManager)
RuntimeEnvironment.application.getSystemService(Context.LOCATION_SERVICE);
private final ShadowLocationManager shadowLocationManager = shadowOf(locationManager);
private final Location someLocation = Utils.location(NETWORK_PROVIDER, 12.0, 20.0);
private final AtomicBoolean notificationVisibility = new AtomicBoolean(false);
private GeofenceApp geofenceApp;
@Before
public void setUp() throws Exception {
initHeadUnitServiceMock();
setupGeofenceApp();
}
private void initHeadUnitServiceMock() {
IBinder headUnitStub = newTestHeadUnitServerBinder();
shadowOf(RuntimeEnvironment.application).setComponentNameAndServiceForBindService(
new ComponentName("com.esrlabs.headunitinterface", "HeadUnit"), headUnitStub);
}
private IBinder newTestHeadUnitServerBinder() {
return new HeadUnit.Stub() {
@Override
public void showNotification(String text) throws RemoteException {
notificationVisibility.set(true);
}
@Override
public void hideAllNotifications() throws RemoteException {
notificationVisibility.set(false);
}
};
}
private void setupGeofenceApp() {
GeofenceApp service = new GeofenceApp(locationManager, someCircleGeofence);
service.onCreate();
geofenceApp = service;
}
@After
public void tearDown() throws Exception {
geofenceApp.onDestroy();
}
@Test
public void shouldReceiveTheLatestLocation() throws Exception {
simulateNewLocation(someLocation);
Location testLocation = geofenceApp.latestLocation();
assertTrue(someLocation.equals(testLocation));
}
@Test
public void shouldShowPopupWhenTheCurrentLocationIsOutsideTheGeofence() throws Exception {
Location locationInside = location(NETWORK_PROVIDER, someCircleGeofence.center.getLatitude() + CircleGeofenceTest.distanceSmallerThanRadiusInDeg,
someCircleGeofence.center.getLongitude());
simulateNewLocation(locationInside);
assertTrue(locationInside.equals(geofenceApp.latestLocation()));
assertFalse(notificationVisibility.get());
Location locationOutside = location(NETWORK_PROVIDER, someCircleGeofence.center.getLatitude() + CircleGeofenceTest.distanceLargerThanRadiusInDeg,
someCircleGeofence.center.getLongitude());
simulateNewLocation(locationOutside);
assertTrue(locationOutside.equals(geofenceApp.latestLocation()));
assertTrue(notificationVisibility.get());
Location nextLocationInside = location(NETWORK_PROVIDER, someCircleGeofence.center.getLatitude() + CircleGeofenceTest.distanceSmallerThanRadiusInDeg,
someCircleGeofence.center.getLongitude());
simulateNewLocation(nextLocationInside);
assertTrue(nextLocationInside.equals(geofenceApp.latestLocation()));
assertFalse(notificationVisibility.get());
}
private void simulateNewLocation(Location someLocation) {
shadowLocationManager.simulateLocation(someLocation);
}
} | true |
2f6d2db80a62b2286a5ce27b592b8070f675e242 | Java | mkuzmik/soa-javaee-labs | /lab3/lab3-apps/src/main/java/soa/mkuzmik/ex5/Movie.java | UTF-8 | 1,303 | 3.28125 | 3 | [] | no_license | package soa.mkuzmik.ex5;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Movie {
private String title;
private String category;
private int year;
private int income;
public static List<Movie> example() {
return Arrays.stream(new Movie[] {
new Movie("Ojciec Chrzestny", "dramat", 1972,120000000),
new Movie("Pluton", "wojenny", 1986, 1000000),
new Movie("Nagi instynkt", "thriller", 1992, 60000),
}).collect(Collectors.toList());
}
public Movie(String title, String category, int year, int income) {
this.title = title;
this.category = category;
this.year = year;
this.income = income;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getCategory() {
return category;
}
public void setCategory(String category) {
this.category = category;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getIncome() {
return income;
}
public void setIncome(int income) {
this.income = income;
}
}
| true |
640a4e27dcf57f81c5e7b6c369cf92ca5374025c | Java | novelrt/FumoCement | /src/main/java/com/github/novelrt/fumocement/HandleDeleter.java | UTF-8 | 466 | 2.125 | 2 | [
"LicenseRef-scancode-other-permissive",
"MIT"
] | permissive | // Copyright ยฉ Matt Jones and Contributors. Licensed under the MIT License (MIT). See LICENCE.md in the repository root for more information.
package com.github.novelrt.fumocement;
/**
* Cleans native resources using a given handle.
*/
@FunctionalInterface
public interface HandleDeleter {
/**
* Cleans any native resources associated to a native handle.
*
* @param handle the native handle
*/
void deleteHandle(@Pointer long handle);
}
| true |
b06dab2ae52677c27fbd6858c27857cbc1c74915 | Java | NewYuanCarl/nyt | /SSM_TT/src/com/liu/biz/IUserBiz.java | UTF-8 | 127 | 1.570313 | 2 | [] | no_license | package com.liu.biz;
import com.liu.pojo.Users;
public interface IUserBiz {
public Users islogin(Users user);
}
| true |
38fd0e49c5ec0a7936204b089a039f7eddb38954 | Java | KidiH/edge-tpu-computation-visualizer | /src/main/java/com/google/sps/structures/IntervalTree.java | UTF-8 | 41,665 | 2.859375 | 3 | [
"Apache-2.0"
] | permissive | // The MIT License (MIT)
// Copyright (c) 2016 Mason M Lai
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
package com.google.sps.structures;
import com.google.sps.exceptions.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Set;
import java.util.List;
/**
* A balanced binary-search tree keyed by Interval objects.
* <p>
* The underlying data-structure is a red-black tree largely implemented from
* CLRS (Introduction to Algorithms, 2nd edition) with the interval-tree
* extensions mentioned in section 14.3
* @param <I> - the type of Interval this tree contains
*/
public class IntervalTree<T extends Interval> implements Iterable<T> {
private Node root; // The root Node.
private Node nil; // The sentinel Node to represent the absence of a node.
private int size; // Size of the tree. Updated by insert() and Node#delete()
/**
* Constructs an empty IntervalTree.
*/
public IntervalTree() {
nil = new Node();
root = nil;
size = 0;
}
/**
* Constructs an IntervalTree containing a single node corresponding to
* the given interval.
* @param t - the interval to add to the tree
*/
public IntervalTree(T t) {
nil = new Node();
root = new Node(t);
root.blacken();
size = 1;
}
public IntervalTree(List<T> list) throws Exception {
this();
for(T t : list) {
this.insert(t);
}
}
///////////////////////////////////
// Tree -- General query methods //
///////////////////////////////////
/**
* Whether this IntervalTree is empty or not.
*/
public boolean isEmpty() {
return root.isNil();
}
/**
* The number of intervals stored in this IntervalTree.
*/
public int size() {
return size;
}
/**
* The Node in this IntervalTree that contains the given Interval.
* <p>
* This method returns the nil Node if the Interval t cannot be found.
* @param t - the Interval to search for.
*/
private Node search(T t) {
return root.search(t);
}
/**
* Whether or not this IntervalTree contains the given Interval.
* @param t - the Interval to search for
*/
public boolean contains(T t) {
return !search(t).isNil();
}
/**
* Whether or not this IntervalTree contains the given point
*/
public T containsAddress(T t) {
Node n = root.searchOverlaps(t);
if (n.isNil()) {
return null;
} else {
return n.interval();
}
}
/**
* The minimum value in this IntervalTree
* @return an Optional containing, if it exists, the minimum value in this
* IntervalTree; otherwise (i.e., if this is empty), an empty Optional.
*/
public Optional<T> minimum() {
Node n = root.minimumNode();
return n.isNil() ? Optional.empty() : Optional.of(n.interval());
}
/**
* The maximum value in this IntervalTree
* @return an Optional containing, if it exists, the maximum value in this
* IntervalTree; otherwise (i.e., if this is empty), an empty Optional.
*/
public Optional<T> maximum() {
Node n = root.maximumNode();
return n.isNil() ? Optional.empty() : Optional.of(n.interval());
}
/**
* The next Interval in this IntervalTree
* @param t - the Interval to search for
* @return an Optional containing, if it exists, the next Interval in this
* IntervalTree; otherwise (if t is the maximum Interval, or if this
* IntervalTree does not contain t), an empty Optional.
*/
public Optional<T> successor(T t) {
Node n = search(t);
if (n.isNil()) {
return Optional.empty();
}
n = n.successor();
if (n.isNil()) {
return Optional.empty();
}
return Optional.of(n.interval());
}
/**
* The previous Interval in this IntervalTree
* @param t - the Interval to search for
* @return an Optional containing, if it exists, the previous Interval in
* this IntervalTree; otherwise (if t is the minimum Interval, or if this
* IntervalTree does not contain t), an empty Optional.
*/
public Optional<T> predecessor(T t) {
Node n = search(t);
if (n.isNil()) {
return Optional.empty();
}
n = n.predecessor();
if (n.isNil()) {
return Optional.empty();
}
return Optional.of(n.interval());
}
/**
* An Iterator which traverses the tree in ascending order.
*/
public Iterator<T> iterator() {
return new TreeIterator(root);
}
/**
* An Iterator over the Intervals in this IntervalTree that overlap the
* given Interval
* @param t - the overlapping Interval
*/
public Iterator<T> overlappers(T t) {
return root.overlappers(t);
}
/**
* Whether or not any of the Intervals in this IntervalTree overlap the given
* Interval
* @param t - the potentially overlapping Interval
*/
public boolean overlaps(T t) {
return !root.anyOverlappingNode(t).isNil();
}
/**
* The number of Intervals in this IntervalTree that overlap the given
* Interval
* @param t - the overlapping Interval
*/
public int numOverlappers(T t) {
return root.numOverlappingNodes(t);
}
/**
* The least Interval in this IntervalTree that overlaps the given Interval
* @param t - the overlapping Interval
* @return an Optional containing, if it exists, the least Interval in this
* IntervalTree that overlaps the given Interval; otherwise (i.e., if there
* is no overlap), an empty Optional
*/
public Optional<T> minimumOverlapper(T t) {
Node n = root.minimumOverlappingNode(t);
return n.isNil() ? Optional.empty() : Optional.of(n.interval());
}
///////////////////////////////
// Tree -- Insertion methods //
///////////////////////////////
/**
* Inserts the given value into the IntervalTree.
* <p>
* This method constructs a new Node containing the given value and places
* it into the tree. If the value already exists within the tree, the tree
* remains unchanged.
* @param t - the value to place into the tree
* @return if the value did not already exist, i.e., true if the tree was
* changed, false if it was not
*/
public boolean insert(T t) throws Exception {
Node z = new Node(t);
Node y = nil;
Node x = root;
if (!(x.searchOverlaps(t).isNil())) {
throw new OverlappingIntervalsException(x.interval(), t);
}
while (!x.isNil()) { // Traverse the tree down to a leaf.
y = x;
x.maxEnd = Math.max(x.maxEnd, z.maxEnd); // Update maxEnd on the way down.
int cmp = z.compareTo(x);
if (cmp == 0) {
return false; // Value already in tree. Do nothing.
}
x = cmp == -1 ? x.left : x.right;
}
z.parent = y;
if (y.isNil()) {
root = z;
root.blacken();
} else { // Set the parent of n.
int cmp = z.compareTo(y);
if (cmp == -1) {
y.left = z;
} else {
assert(cmp == 1);
y.right = z;
}
z.left = nil;
z.right = nil;
z.redden();
z.insertFixup();
}
size++;
return true;
}
//////////////////////////////
// Tree -- Deletion methods //
//////////////////////////////
/**
* Deletes the given value from this IntervalTree.
* <p>
* If the value does not exist, this IntervalTree remains unchanged.
* @param t - the Interval to delete from the tree
* @return whether or not an Interval was removed from this IntervalTree
*/
public boolean delete(T t) { // Node#delete does nothing and returns
return search(t).delete(); // false if t.isNil()
}
/**
* Deletes the smallest Interval from this IntervalTree.
* <p>
* If there is no smallest Interval (that is, if the tree is empty), this
* IntervalTree remains unchanged.
* @return whether or not an Interval was removed from this IntervalTree
*/
public boolean deleteMin() { // Node#delete does nothing and
return root.minimumNode().delete(); // returns false if t.isNil()
}
/**
* Deletes the greatest Interval from this IntervalTree.
* <p>
* If there is no greatest Interval (that is, if the tree is empty), this
* IntervalTree remains unchanged.
* @return whether or not an Interval was removed from this IntervalTree
*/
public boolean deleteMax() { // Node#delete does nothing and
return root.maximumNode().delete(); // returns false if t.isNil()
}
/**
* Deletes all Intervals that overlap the given Interval from this
* IntervalTree.
* <p>
* If there are no overlapping Intervals, this IntervalTree remains
* unchanged.
* @param t - the overlapping Interval
* @return whether or not an Interval was removed from this IntervalTree
*/
public boolean deleteOverlappers(T t) {
// TODO
// Replacing the line
// s.forEach(n -> delete(n.interval()))
// with
// s.forEach(n -> n.delete())
// causes a NullPointerException in resetMaxEnd(). Why?!
//
// As it stands, every deletion operation causes the tree
// to be searched. Fix this, please.
Set<Node> s = new HashSet<Node>();
Iterator<Node> iter = new OverlappingNodeIterator(root, t);
iter.forEachRemaining(s::add);
return s.stream()
.map(n -> delete(n.interval))
.reduce(false, (a, b) -> a || b);
}
/**
* A representation of a node in an interval tree.
*/
private class Node implements Interval {
/* Most of the "guts" of the interval tree are actually methods called
* by nodes. For example, IntervalTree#delete(val) searches up the Node
* containing val; then that Node deletes itself with Node#delete().
*/
private T interval;
private Node parent;
private Node left;
private Node right;
private boolean isBlack;
private int maxEnd;
/**
* Constructs a Node with no data.
* <p>
* This Node has a null interval field, is black, and has all pointers
* pointing at itself. This is intended to be used as the sentinel
* node in the tree ("nil" in CLRS).
*/
private Node() {
parent = this;
left = this;
right = this;
blacken();
}
/**
* Constructs a Node containing the given Interval.
* @param data - the Interval to be contained within this Node
*/
public Node(T interval) {
this.interval = interval;
parent = nil;
left = nil;
right = nil;
maxEnd = interval.end();
redden();
}
/**
* The Interval in this Node
*/
public T interval() {
return interval;
}
/**
* The start of the Interval in this Node
*/
@Override
public int start() {
return interval.start();
}
/**
* The end of the Interval in this Node
*/
@Override
public int end() {
return interval.end();
}
///////////////////////////////////
// Node -- General query methods //
///////////////////////////////////
/**
* Searches the subtree rooted at this Node for the given Interval.
* @param t - the Interval to search for
* @return the Node with the given Interval, if it exists; otherwise,
* the sentinel Node
*/
private Node search(T t) {
Node n = this;
while (!n.isNil() && t.compareTo(n) != 0) {
n = t.compareTo(n) == -1 ? n.left : n.right;
}
return n;
}
private Node searchOverlaps(T t) {
Node n = this;
while (!n.isNil() && !t.overlaps(n)) {
n = t.compareTo(n) == -1 ? n.left : n.right;
}
return n;
}
/**
* Searches the subtree rooted at this Node for its minimum Interval.
* @return the Node with the minimum Interval, if it exists; otherwise,
* the sentinel Node
*/
private Node minimumNode() {
Node n = this;
while (!n.left.isNil()) {
n = n.left;
}
return n;
}
/**
* Searches the subtree rooted at this Node for its maximum Interval.
* @return the Node with the maximum Interval, if it exists; otherwise,
* the sentinel Node
*/
private Node maximumNode() {
Node n = this;
while (!n.right.isNil()) {
n = n.right;
}
return n;
}
/**
* The successor of this Node.
* @return the Node following this Node, if it exists; otherwise the
* sentinel Node
*/
private Node successor() {
if (!right.isNil()) {
return right.minimumNode();
}
Node x = this;
Node y = parent;
while (!y.isNil() && x == y.right) {
x = y;
y = y.parent;
}
return y;
}
/**
* The predecessor of this Node.
* @return the Node preceding this Node, if it exists; otherwise the
* sentinel Node
*/
private Node predecessor() {
if (!left.isNil()) {
return left.maximumNode();
}
Node x = this;
Node y = parent;
while (!y.isNil() && x == y.left) {
x = y;
y = y.parent;
}
return y;
}
///////////////////////////////////////
// Node -- Overlapping query methods //
///////////////////////////////////////
/**
* Returns a Node from this Node's subtree that overlaps the given
* Interval.
* <p>
* The only guarantee of this method is that the returned Node overlaps
* the Interval t. This method is meant to be a quick helper method to
* determine if any overlap exists between an Interval and any of an
* IntervalTree's Intervals. The returned Node will be the first
* overlapping one found.
* @param t - the given Interval
* @return an overlapping Node from this Node's subtree, if one exists;
* otherwise the sentinel Node
*/
private Node anyOverlappingNode(T t) {
Node x = this;
while (!x.isNil() && !t.overlaps(x.interval)) {
x = !x.left.isNil() && x.left.maxEnd > t.start() ? x.left : x.right;
}
return x;
}
/**
* Returns the minimum Node from this Node's subtree that overlaps the
* given Interval.
* @param t - the given Interval
* @return the minimum Node from this Node's subtree that overlaps the
* Interval t, if one exists; otherwise, the sentinel Node
*/
private Node minimumOverlappingNode(T t) {
Node result = nil;
Node n = this;
if (!n.isNil() && n.maxEnd > t.start()) {
while (true) {
if (n.overlaps(t)) {
// This node overlaps. There may be a lesser overlapper
// down the left subtree. No need to consider the right
// as all overlappers there will be greater.
result = n;
n = n.left;
if (n.isNil() || n.maxEnd <= t.start()) {
// Either no left subtree, or nodes can't overlap.
break;
}
} else {
// This node doesn't overlap.
// Check the left subtree if an overlapper may be there
Node left = n.left;
if (!left.isNil() && left.maxEnd > t.start()) {
n = left;
} else {
// Left subtree cannot contain an overlapper. Check the
// right sub-tree.
if (n.start() >= t.end()) {
// Nothing in the right subtree can overlap
break;
}
n = n.right;
if (n.isNil() || n.maxEnd <= t.start()) {
// No right subtree, or nodes can't overlap.
break;
}
}
}
}
}
return result;
}
/**
* An Iterator over all values in this Node's subtree that overlap the
* given Interval t.
* @param t - the overlapping Interval
*/
private Iterator<T> overlappers(T t) {
return new OverlapperIterator(this, t);
}
/**
* The next Node (relative to this Node) which overlaps the given
* Interval t
* @param t - the overlapping Interval
* @return the next Node that overlaps the Interval t, if one exists;
* otherwise, the sentinel Node
*/
private Node nextOverlappingNode(T t) {
Node x = this;
Node rtrn = nil;
// First, check the right subtree for its minimum overlapper.
if (!right.isNil()) {
rtrn = x.right.minimumOverlappingNode(t);
}
// If we didn't find it in the right subtree, walk up the tree and
// check the parents of left-children as well as their right subtrees.
while (!x.parent.isNil() && rtrn.isNil()) {
if (x.isLeftChild()) {
rtrn = x.parent.overlaps(t) ? x.parent
: x.parent.right.minimumOverlappingNode(t);
}
x = x.parent;
}
return rtrn;
}
/**
* The number of Nodes in this Node's subtree that overlap the given
* Interval t.
* <p>
* This number includes this Node if this Node overlaps t. This method
* iterates over all overlapping Nodes, so if you ultimately need to
* inspect the Nodes, it will be more efficient to simply create the
* Iterator yourself.
* @param t - the overlapping Interval
* @return the number of overlapping Nodes
*/
private int numOverlappingNodes(T t) {
int count = 0;
Iterator<Node> iter = new OverlappingNodeIterator(this, t);
while (iter.hasNext()) {
iter.next();
count++;
}
return count;
}
//////////////////////////////
// Node -- Deletion methods //
//////////////////////////////
//TODO: Should we rewire the Nodes rather than copying data?
// I suspect this method causes some code which seems like it
// should work to fail.
/**
* Deletes this Node from its tree.
* <p>
* More specifically, removes the data held within this Node from the
* tree. Depending on the structure of the tree at this Node, this
* particular Node instance may not be removed; rather, a different
* Node may be deleted and that Node's contents copied into this one,
* overwriting the previous contents.
*/
private boolean delete() {
if (isNil()) { // Can't delete the sentinel node.
return false;
}
Node y = this;
if (hasTwoChildren()) { // If the node to remove has two children,
y = successor(); // copy the successor's data into it and
copyData(y); // remove the successor. The successor is
maxEndFixup(); // guaranteed to both exist and have at most
} // one child, so we've converted the two-
// child case to a one- or no-child case.
Node x = y.left.isNil() ? y.right : y.left;
x.parent = y.parent;
if (y.isRoot()) {
root = x;
} else if (y.isLeftChild()) {
y.parent.left = x;
y.maxEndFixup();
} else {
y.parent.right = x;
y.maxEndFixup();
}
if (y.isBlack) {
x.deleteFixup();
}
size--;
return true;
}
////////////////////////////////////////////////
// Node -- Tree-invariant maintenance methods //
////////////////////////////////////////////////
/**
* Whether or not this Node is the root of its tree.
*/
public boolean isRoot() {
return (!isNil() && parent.isNil());
}
/**
* Whether or not this Node is the sentinel node.
*/
public boolean isNil() {
return this == nil;
}
/**
* Whether or not this Node is the left child of its parent.
*/
public boolean isLeftChild() {
return this == parent.left;
}
/**
* Whether or not this Node is the right child of its parent.
*/
public boolean isRightChild() {
return this == parent.right;
}
/**
* Whether or not this Node has no children, i.e., is a leaf.
*/
public boolean hasNoChildren() {
return left.isNil() && right.isNil();
}
/**
* Whether or not this Node has two children, i.e., neither of its
* children are leaves.
*/
public boolean hasTwoChildren() {
return !left.isNil() && !right.isNil();
}
/**
* Sets this Node's color to black.
*/
private void blacken() {
isBlack = true;
}
/**
* Sets this Node's color to red.
*/
private void redden() {
isBlack = false;
}
/**
* Whether or not this Node's color is red.
*/
public boolean isRed() {
return !isBlack;
}
/**
* A pointer to the grandparent of this Node.
*/
private Node grandparent() {
return parent.parent;
}
/**
* Sets the maxEnd value for this Node.
* <p>
* The maxEnd value should be the highest of:
* <ul>
* <li>the end value of this node's data
* <li>the maxEnd value of this node's left child, if not null
* <li>the maxEnd value of this node's right child, if not null
* </ul><p>
* This method will be correct only if the left and right children have
* correct maxEnd values.
*/
private void resetMaxEnd() {
int val = interval.end();
if (!left.isNil()) {
val = Math.max(val, left.maxEnd);
}
if (!right.isNil()) {
val = Math.max(val, right.maxEnd);
}
maxEnd = val;
}
/**
* Sets the maxEnd value for this Node, and all Nodes up to the root of
* the tree.
*/
private void maxEndFixup() {
Node n = this;
n.resetMaxEnd();
while (!n.parent.isNil()) {
n = n.parent;
n.resetMaxEnd();
}
}
/**
* Performs a left-rotation on this Node.
* @see - Cormen et al. "Introduction to Algorithms", 2nd ed, pp. 277-279.
*/
private void leftRotate() {
Node y = right;
right = y.left;
if (!y.left.isNil()) {
y.left.parent = this;
}
y.parent = parent;
if (parent.isNil()) {
root = y;
} else if (isLeftChild()) {
parent.left = y;
} else {
parent.right = y;
}
y.left = this;
parent = y;
resetMaxEnd();
y.resetMaxEnd();
}
/**
* Performs a right-rotation on this Node.
* @see - Cormen et al. "Introduction to Algorithms", 2nd ed, pp. 277-279.
*/
private void rightRotate() {
Node y = left;
left = y.right;
if (!y.right.isNil()) {
y.right.parent = this;
}
y.parent = parent;
if (parent.isNil()) {
root = y;
} else if (isLeftChild()) {
parent.left = y;
} else {
parent.right = y;
}
y.right = this;
parent = y;
resetMaxEnd();
y.resetMaxEnd();
}
/**
* Copies the data from a Node into this Node.
* @param o - the other Node containing the data to be copied
*/
private void copyData(Node o) {
interval = o.interval;
}
@Override
public String toString() {
if (isNil()) {
return "nil";
} else {
String color = isBlack ? "black" : "red";
return "start = " + start() +
"\nend = " + end() +
"\nmaxEnd = " + maxEnd +
"\ncolor = " + color;
}
}
/**
* Ensures that red-black constraints and interval-tree constraints are
* maintained after an insertion.
*/
private void insertFixup() {
Node z = this;
while (z.parent.isRed()) {
if (z.parent.isLeftChild()) {
Node y = z.parent.parent.right;
if (y.isRed()) {
z.parent.blacken();
y.blacken();
z.grandparent().redden();
z = z.grandparent();
} else {
if (z.isRightChild()) {
z = z.parent;
z.leftRotate();
}
z.parent.blacken();
z.grandparent().redden();
z.grandparent().rightRotate();
}
} else {
Node y = z.grandparent().left;
if (y.isRed()) {
z.parent.blacken();
y.blacken();
z.grandparent().redden();
z = z.grandparent();
} else {
if (z.isLeftChild()) {
z = z.parent;
z.rightRotate();
}
z.parent.blacken();
z.grandparent().redden();
z.grandparent().leftRotate();
}
}
}
root.blacken();
}
/**
* Ensures that red-black constraints and interval-tree constraints are
* maintained after deletion.
*/
private void deleteFixup() {
Node x = this;
while (!x.isRoot() && x.isBlack) {
if (x.isLeftChild()) {
Node w = x.parent.right;
if (w.isRed()) {
w.blacken();
x.parent.redden();
x.parent.leftRotate();
w = x.parent.right;
}
if (w.left.isBlack && w.right.isBlack) {
w.redden();
x = x.parent;
} else {
if (w.right.isBlack) {
w.left.blacken();
w.redden();
w.rightRotate();
w = x.parent.right;
}
w.isBlack = x.parent.isBlack;
x.parent.blacken();
w.right.blacken();
x.parent.leftRotate();
x = root;
}
} else {
Node w = x.parent.left;
if (w.isRed()) {
w.blacken();
x.parent.redden();
x.parent.rightRotate();
w = x.parent.left;
}
if (w.left.isBlack && w.right.isBlack) {
w.redden();
x = x.parent;
} else {
if (w.left.isBlack) {
w.right.blacken();
w.redden();
w.leftRotate();
w = x.parent.left;
}
w.isBlack = x.parent.isBlack;
x.parent.blacken();
w.left.blacken();
x.parent.rightRotate();
x = root;
}
}
}
x.blacken();
}
///////////////////////////////
// Node -- Debugging methods //
///////////////////////////////
/**
* Whether or not the subtree rooted at this Node is a valid
* binary-search tree.
* @param min - a lower-bound Node
* @param max - an upper-bound Node
*/
private boolean isBST(Node min, Node max) {
if (isNil()) {
return true; // Leaves are a valid BST, trivially.
}
if (min != null && compareTo(min) <= 0) {
return false; // This Node must be greater than min
}
if (max != null && compareTo(max) >= 0) {
return false; // and less than max.
}
// Children recursively call method with updated min/max.
return left.isBST(min, this) && right.isBST(this, max);
}
/**
* Whether or not the subtree rooted at this Node is balanced.
* <p>
* Balance determination is done by calculating the black-height.
* @param black - the expected black-height of this subtree
*/
private boolean isBalanced(int black) {
if (isNil()) {
return black == 0; // Leaves have a black-height of zero,
} // even though they are black.
if (isBlack) {
black--;
}
return left.isBalanced(black) && right.isBalanced(black);
}
/**
* Whether or not the subtree rooted at this Node has a valid
* red-coloring.
* <p>
* A red-black tree has a valid red-coloring if every red node has two
* black children.
*/
private boolean hasValidRedColoring() {
if (isNil()) {
return true;
} else if (isBlack) {
return left.hasValidRedColoring() &&
right.hasValidRedColoring();
} else {
return left.isBlack && right.isBlack &&
left.hasValidRedColoring() &&
right.hasValidRedColoring();
}
}
/**
* Whether or not the subtree rooted at this Node has consistent maxEnd
* values.
* <p>
* The maxEnd value of an interval-tree Node is equal to the maximum of
* the end-values of all intervals contained in the Node's subtree.
*/
private boolean hasConsistentMaxEnds() {
if (isNil()) { // 1. sentinel node
return true;
}
if (hasNoChildren()) { // 2. leaf node
return maxEnd == end();
} else {
boolean consistent = maxEnd >= end();
if (hasTwoChildren()) { // 3. two children
return consistent &&
maxEnd >= left.maxEnd &&
maxEnd >= right.maxEnd &&
left.hasConsistentMaxEnds() &&
right.hasConsistentMaxEnds();
} else if (left.isNil()) { // 4. one child -- right
return consistent &&
maxEnd >= right.maxEnd &&
right.hasConsistentMaxEnds();
} else {
return consistent && // 5. one child -- left
maxEnd >= left.maxEnd &&
left.hasConsistentMaxEnds();
}
}
}
}
///////////////////////
// Tree -- Iterators //
///////////////////////
/**
* An Iterator which walks along this IntervalTree's Nodes in ascending order.
*/
private class TreeNodeIterator implements Iterator<Node> {
private Node next;
private TreeNodeIterator(Node root) {
next = root.minimumNode();
}
@Override
public boolean hasNext() {
return !next.isNil();
}
@Override
public Node next() {
if (!hasNext()) {
throw new NoSuchElementException("Interval tree has no more elements.");
}
Node rtrn = next;
next = rtrn.successor();
return rtrn;
}
}
/**
* An Iterator which walks along this IntervalTree's Intervals in ascending
* order.
* <p>
* This class just wraps a TreeNodeIterator and extracts each Node's Interval.
*/
private class TreeIterator implements Iterator<T> {
private TreeNodeIterator nodeIter;
private TreeIterator(Node root) {
nodeIter = new TreeNodeIterator(root);
}
@Override
public boolean hasNext() {
return nodeIter.hasNext();
}
@Override
public T next() {
return nodeIter.next().interval;
}
}
/**
* An Iterator which walks along this IntervalTree's Nodes that overlap
* a given Interval in ascending order.
*/
private class OverlappingNodeIterator implements Iterator<Node> {
private Node next;
private T interval;
private OverlappingNodeIterator(Node root, T t) {
interval = t;
next = root.minimumOverlappingNode(interval);
}
@Override
public boolean hasNext() {
return !next.isNil();
}
@Override
public Node next() {
if (!hasNext()) {
throw new NoSuchElementException("Interval tree has no more overlapping elements.");
}
Node rtrn = next;
next = rtrn.nextOverlappingNode(interval);
return rtrn;
}
}
/**
* An Iterator which walks along this IntervalTree's Intervals that overlap
* a given Interval in ascending order.
* <p>
* This class just wraps an OverlappingNodeIterator and extracts each Node's
* Interval.
*/
private class OverlapperIterator implements Iterator<T> {
private OverlappingNodeIterator nodeIter;
private OverlapperIterator(Node root, T t) {
nodeIter = new OverlappingNodeIterator(root, t);
}
@Override
public boolean hasNext() {
return nodeIter.hasNext();
}
@Override
public T next() {
return nodeIter.next().interval;
}
}
///////////////////////////////
// Tree -- Debugging methods //
///////////////////////////////
/**
* Whether or not this IntervalTree is a valid binary-search tree.
* <p>
* This method will return false if any Node is less than its left child
* or greater than its right child.
* <p>
* This method is used for debugging only, and its access is changed in
* testing.
*/
@SuppressWarnings("unused")
private boolean isBST() {
return root.isBST(null, null);
}
/**
* Whether or not this IntervalTree is balanced.
* <p>
* This method will return false if all of the branches (from root to leaf)
* do not contain the same number of black nodes. (Specifically, the
* black-number of each branch is compared against the black-number of the
* left-most branch.)
* <p>
* This method is used for debugging only, and its access is changed in
* testing.
*/
@SuppressWarnings("unused")
private boolean isBalanced() {
int black = 0;
Node x = root;
while (!x.isNil()) {
if (x.isBlack) {
black++;
}
x = x.left;
}
return root.isBalanced(black);
}
/**
* Whether or not this IntervalTree has a valid red coloring.
* <p>
* This method will return false if all of the branches (from root to leaf)
* do not contain the same number of black nodes. (Specifically, the
* black-number of each branch is compared against the black-number of the
* left-most branch.)
* <p>
* This method is used for debugging only, and its access is changed in
* testing.
*/
@SuppressWarnings("unused")
private boolean hasValidRedColoring() {
return root.hasValidRedColoring();
}
/**
* Whether or not this IntervalTree has consistent maxEnd values.
* <p>
* This method will only return true if each Node has a maxEnd value equal
* to the highest interval end value of all the intervals in its subtree.
* <p>
* This method is used for debugging only, and its access is changed in
* testing.
*/
@SuppressWarnings("unused")
private boolean hasConsistentMaxEnds() {
return root.hasConsistentMaxEnds();
}
} | true |
328242ed26c3f1532aa5dc7f94bf1726cb00aba3 | Java | perglervitek/TS1-codes | /ts1-hw03-selenium/src/main/java/cz/cvut/fel/ts1/pages/Article.java | UTF-8 | 1,151 | 2.5625 | 3 | [] | no_license | package cz.cvut.fel.ts1.pages;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
public class Article {
private WebDriver driver;
@FindBy(css = "h1")
private WebElement articleTitleText;
@FindBy(css = "header time")
private WebElement publishedDateText;
@FindBy(css = ".c-bibliographic-information__value > a")
private WebElement doiAnchor;
private static final String articleUrl = "https://link.springer.com/article";
public Article(WebDriver driver) {
this.driver = driver;
if (!driver.getCurrentUrl().contains(articleUrl)) {
throw new IllegalStateException("Invalid url address expected: " + articleUrl + " got: " + driver.getCurrentUrl());
}
PageFactory.initElements(driver, this);
}
public String getTitle() {
return articleTitleText.getText();
}
public String getDoi(){
return doiAnchor.getAttribute("href");
}
public String getPublishedDate(){
return publishedDateText.getText();
}
}
| true |
411f185cd4278a6ff80954147088b7b65219ef7b | Java | ankeshkatiyar/worksplit-app-project | /src/main/java/com/worksplit/exceptions/UserAlreadyExistException.java | UTF-8 | 215 | 2.34375 | 2 | [] | no_license | package com.worksplit.exceptions;
public class UserAlreadyExistException extends RuntimeException {
public UserAlreadyExistException(String user) {
super(user + " already exist in the system");
}
}
| true |
d021e3605348535d695d7c71b3409dcd88176db4 | Java | chengjingming060241/bllc | /gizwits-lease-master/gizwits-lease-backend/src/test/java/com/gizwits/boot/gen/MpGenerator.java | UTF-8 | 4,063 | 2.046875 | 2 | [] | no_license | package com.gizwits.boot.gen;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
import com.baomidou.mybatisplus.generator.config.rules.DbColumnType;
import com.baomidou.mybatisplus.generator.config.rules.DbType;
import com.gizwits.boot.utils.MpGeneratorUtil;
/**
* <p>
* ไปฃ็ ็ๆๅจๆผ็คบ
* </p>
*/
public class MpGenerator {
/**
* <p>
* MySQL ็ๆๆผ็คบ
* </p>
*/
public static void main(String[] args) {
DataSourceConfig dsc = new DataSourceConfig();
dsc.setDbType(DbType.MYSQL);
dsc.setTypeConvert(new MySqlTypeConvert(){
//่ชๅฎไนๆฐๆฎๅบ่กจๅญๆฎต็ฑปๅ่ฝฌๆขใๅฏ้ใ
@Override
public DbColumnType processTypeConvert(String fieldType) {
return super.processTypeConvert(fieldType);
}
});
dsc.setDriverName("com.mysql.jdbc.Driver");
dsc.setUsername("lease");
dsc.setPassword("^gizwits-lease-admin$");
dsc.setUrl("jdbc:mysql://119.29.216.25:3306/weibo?characterEncoding=utf8&useSSL=true");
createBean(dsc);
String modelOutputStr="/Users/yehongwei/gizwits/gizwits-lease/gizwits-lease-model/src/main/java";
MpGeneratorUtil.createModel(dsc,modelOutputStr,"yinhui","com.gizwits.lease","benefit",null,
new String[]{"share_profit_summary","share_profit_summary_detail"},null);
String daoOutputStr = "/Users/yehongwei/gizwits/gizwits-lease/gizwits-lease-dao/src/main/java";
MpGeneratorUtil.createDao(dsc,daoOutputStr,"yinhui","com.gizwits.lease","benefit",null,
new String[]{"share_profit_summary","share_profit_summary_detail"},null);
String serviceOutputStr = "/Users/yehongwei/gizwits/gizwits-lease/gizwits-lease-service/src/main/java";
MpGeneratorUtil.createService(dsc,serviceOutputStr,"yinhui","com.gizwits.lease","benefit",null,
new String[]{"share_profit_summary","share_profit_summary_detail"},null);
String controllerOutputStr = "/Users/yehongwei/gizwits/gizwits-lease/gizwits-lease-backend/src/main/java";
MpGeneratorUtil.createController(dsc,controllerOutputStr,"yinhui","com.gizwits.lease","benefit",null,
new String[]{"share_profit_summary","share_profit_summary_detail"},null);
String mapperDir = "/Users/yehongwei/gizwits/gizwits-lease/gizwits-lease-dao/src/main/resources/mapper/";
MpGeneratorUtil.createMapperXml(dsc,mapperDir, "yinhui","com.gizwits.lease","benefit",null,
new String[]{"share_profit_summary","share_profit_summary_detail"},null);
}
private static void createBean(DataSourceConfig dsc) {
String modelOutputStr="G:/code/java/gizwits-lease-aep/gizwits-lease-model/src/main/java";
MpGeneratorUtil.createModel(dsc,modelOutputStr,"Joke","com.gizwits.lease","order",null,
new String[]{"order_data_flow"},null);
String daoOutputStr = "G:/code/java/gizwits-lease-aep/gizwits-lease-dao/src/main/java";
MpGeneratorUtil.createDao(dsc,daoOutputStr,"Joke","com.gizwits.lease","order",null,
new String[]{"order_data_flow"},null);
String serviceOutputStr = "G:/code/java/gizwits-lease-aep/gizwits-lease-service/src/main/java";
MpGeneratorUtil.createService(dsc,serviceOutputStr,"Joke","com.gizwits.lease","order",null,
new String[]{"order_data_flow"},null);
String controllerOutputStr = "G:/code/java/gizwits-lease-aep/gizwits-lease-backend/src/main/java";
MpGeneratorUtil.createController(dsc,controllerOutputStr,"Joke","com.gizwits.lease","order",null,
new String[]{"order_data_flow"},null);
String mapperOutputDir = "G:/code/java/gizwits-lease-aep/gizwits-lease-dao/src/main/resources/mapper/";
MpGeneratorUtil.createMapperXml(dsc,mapperOutputDir, "Joke","com.gizwits.lease","order",null,
new String[]{"order_data_flow"},null);
}
} | true |
b7f3e5946142ce3825633e30a5db7cb9e1bca024 | Java | tnducrocq/ufc | /app/src/main/java/fr/tnducrocq/ufc/presentation/CategoryActivity.java | UTF-8 | 3,646 | 2.046875 | 2 | [] | no_license | package fr.tnducrocq.ufc.presentation;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.MenuItem;
import java.util.List;
import butterknife.BindView;
import butterknife.ButterKnife;
import fr.tnducrocq.ufc.data.entity.fighter.Fighter;
import fr.tnducrocq.ufc.data.entity.fighter.WeightCategory;
import fr.tnducrocq.ufc.presentation.app.App;
import fr.tnducrocq.ufc.presentation.ui.category.CategoryAdapter;
import rx.Observer;
/**
* Created by tony on 11/08/2017.
*/
public class CategoryActivity extends AppCompatActivity {
public static final String TAG = "CategoryActivity";
public static final String EXTRA_CATEGORY = "extra_category";
public static Intent newIntent(Context context, WeightCategory category) {
Intent intent = new Intent(context, CategoryActivity.class);
intent.putExtra(EXTRA_CATEGORY, category);
return intent;
}
public WeightCategory mWeightCategory;
@BindView(R.id.category_toolbar)
public Toolbar mToolbar;
@BindView(R.id.category_fighters)
public RecyclerView mRecyclerView;
private CategoryAdapter mAdapter;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_category);
ButterKnife.bind(this);
mWeightCategory = (WeightCategory) getIntent().getSerializableExtra(EXTRA_CATEGORY);
mToolbar.setTitle(mWeightCategory.getResourceId());
setSupportActionBar(mToolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
getSupportActionBar().setDisplayShowHomeEnabled(true);
App.getInstance().getFighterRepository().get(mWeightCategory).
subscribeOn(App.getInstance().getSchedulerProvider().multi()).
observeOn(App.getInstance().getSchedulerProvider().ui()).
subscribe(new Observer<List<Fighter>>() {
protected List<Fighter> mFighters;
@Override
public void onCompleted() {
if (mFighters != null) {
setAdapter(mFighters);
}
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError", e);
Snackbar snackbar = Snackbar.make(CategoryActivity.this.findViewById(android.R.id.content), e.getLocalizedMessage(), Snackbar.LENGTH_LONG);
snackbar.show();
}
@Override
public void onNext(List<Fighter> values) {
mFighters = values;
}
});
}
private void setAdapter(List<Fighter> fighters) {
mAdapter = new CategoryAdapter(fighters);
mAdapter.setOnFighterInteractionListener(fighter -> {
Intent intent = FighterActivity.newIntent(getBaseContext(), fighter);
startActivity(intent);
});
mRecyclerView.setAdapter(mAdapter);
}
@Override
public boolean onOptionsItemSelected(MenuItem menuItem) {
if (menuItem.getItemId() == android.R.id.home) {
finish();
}
return super.onOptionsItemSelected(menuItem);
}
}
| true |
099f65d9ce1da0882fbc4ab7ce7d4a2487f9e634 | Java | thwippp/InventorySystem | /src/Model/Part.java | UTF-8 | 2,089 | 2.875 | 3 | [] | no_license | package Model;
/**
*
* @author Brian Schaffeld
*/
public abstract class Part {
// Instance Variables
// Protected so that subclasses can use these variables
protected int partId;
protected String partName;
protected double partPrice;
protected int partStock;
protected int partMin;
protected int partMax;
// Constructor
public Part(String partName, double partPrice, int partStock, int partMin, int partMax) {
// this.partId = partId;
int nextId = Inventory.getPartIdAutoGen() + 1;
setPartId(nextId);
Inventory.setPartIdAutoGen(nextId);
this.partName = partName;
this.partPrice = partPrice;
this.partStock = partStock;
this.partMin = partMin;
this.partMax = partMax;
}
// public Part(int partId, String partName, double partPrice, int partStock, int partMin, int partMax) {
// this.partId = partId;
// this.partName = partName;
// this.partPrice = partPrice;
// this.partStock = partStock;
// this.partMin = partMin;
// this.partMax = partMax;
// }
public int getPartId() {
return partId;
}
public void setPartId(int partId) {
this.partId = partId;
}
public String getPartName() {
return partName;
}
public void setPartName(String partName) {
this.partName = partName;
}
public double getPartPrice() {
return partPrice;
}
public void setPartPrice(double partPrice) {
this.partPrice = partPrice;
}
public int getPartStock() {
return partStock;
}
public void setPartStock(int partStock) {
this.partStock = partStock;
}
public int getPartMin() {
return partMin;
}
public void setPartMin(int partMin) {
this.partMin = partMin;
}
public int getPartMax() {
return partMax;
}
public void setPartMax(int partMax) {
this.partMax = partMax;
}
}
| true |
6a285ee6695d599c549e1d3fdf257d99ccfc22ef | Java | s9329/NewProjekt | /Projekt/src/main/java/PJWSTK/Projekt/PersonManager.java | UTF-8 | 498 | 2.546875 | 3 | [] | no_license | package PJWSTK.Projekt;
import java.util.List;
import PJWSTK.Projekt.PersonDB;
import PJWSTK.Projekt.PersonInterface;
public class PersonManager implements PersonInterface{
private Metody db = new Metody();
public boolean addPerson(PersonDB obj) {
return db.addPerson(obj);
}
public boolean removePerson(PersonDB obj) {
return db.removePerson(obj);
}
public boolean removeAllPets(PersonDB obj) {
return db.removeAllPets(obj);
}
public List<PersonDB> getAll() {
return db.getAll();
}
} | true |
9abc037345932b57c744f20b69d4c45fc5ccd89a | Java | honeyflyfish/com.tencent.mm | /src/com/tencent/mm/svg/a/a/ui.java | UTF-8 | 3,859 | 1.75 | 2 | [] | no_license | package com.tencent.mm.svg.a.a;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Cap;
import android.graphics.Paint.Join;
import android.graphics.Paint.Style;
import android.graphics.Path;
import android.os.Looper;
import com.tencent.mm.svg.WeChatSVGRenderC2Java;
import com.tencent.mm.svg.c;
public final class ui
extends c
{
private final int height = 120;
private final int width = 120;
protected final int i(int paramInt, Object... paramVarArgs)
{
switch (paramInt)
{
}
for (;;)
{
return 0;
return 120;
return 120;
Canvas localCanvas = (Canvas)paramVarArgs[0];
paramVarArgs = (Looper)paramVarArgs[1];
c.d(paramVarArgs);
c.c(paramVarArgs);
Paint localPaint = c.g(paramVarArgs);
localPaint.setFlags(385);
localPaint.setStyle(Paint.Style.FILL);
Object localObject = c.g(paramVarArgs);
((Paint)localObject).setFlags(385);
((Paint)localObject).setStyle(Paint.Style.STROKE);
localPaint.setColor(-16777216);
((Paint)localObject).setStrokeWidth(1.0F);
((Paint)localObject).setStrokeCap(Paint.Cap.BUTT);
((Paint)localObject).setStrokeJoin(Paint.Join.MITER);
((Paint)localObject).setStrokeMiter(4.0F);
((Paint)localObject).setPathEffect(null);
c.a((Paint)localObject, paramVarArgs).setStrokeWidth(1.0F);
localPaint = c.a(localPaint, paramVarArgs);
localPaint.setColor(-1);
localCanvas.save();
localPaint = c.a(localPaint, paramVarArgs);
localObject = c.h(paramVarArgs);
((Path)localObject).moveTo(93.3855F, 21.88889F);
((Path)localObject).lineTo(116.007385F, 21.88889F);
((Path)localObject).cubicTo(118.21054F, 21.88889F, 120.0F, 23.678875F, 120.0F, 25.886936F);
((Path)localObject).lineTo(120.0F, 105.00195F);
((Path)localObject).cubicTo(120.0F, 107.200554F, 118.21245F, 109.0F, 116.007385F, 109.0F);
((Path)localObject).lineTo(3.9926147F, 109.0F);
((Path)localObject).cubicTo(1.7894608F, 109.0F, 0.0F, 107.210014F, 0.0F, 105.00195F);
((Path)localObject).lineTo(0.0F, 25.886936F);
((Path)localObject).cubicTo(0.0F, 23.688334F, 1.7875545F, 21.88889F, 3.9926147F, 21.88889F);
((Path)localObject).lineTo(26.614498F, 21.88889F);
((Path)localObject).lineTo(38.18182F, 11.0F);
((Path)localObject).lineTo(81.818184F, 11.0F);
((Path)localObject).lineTo(93.3855F, 21.88889F);
((Path)localObject).lineTo(93.3855F, 21.88889F);
((Path)localObject).close();
((Path)localObject).moveTo(60.0F, 98.111115F);
((Path)localObject).cubicTo(80.083084F, 98.111115F, 96.36364F, 81.8607F, 96.36364F, 61.814816F);
((Path)localObject).cubicTo(96.36364F, 41.768925F, 80.083084F, 25.518518F, 60.0F, 25.518518F);
((Path)localObject).cubicTo(39.91692F, 25.518518F, 23.636364F, 41.768925F, 23.636364F, 61.814816F);
((Path)localObject).cubicTo(23.636364F, 81.8607F, 39.91692F, 98.111115F, 60.0F, 98.111115F);
((Path)localObject).close();
((Path)localObject).moveTo(60.0F, 85.40741F);
((Path)localObject).cubicTo(73.054F, 85.40741F, 83.63636F, 74.84464F, 83.63636F, 61.814816F);
((Path)localObject).cubicTo(83.63636F, 48.784985F, 73.054F, 38.22222F, 60.0F, 38.22222F);
((Path)localObject).cubicTo(46.945995F, 38.22222F, 36.363636F, 48.784985F, 36.363636F, 61.814816F);
((Path)localObject).cubicTo(36.363636F, 74.84464F, 46.945995F, 85.40741F, 60.0F, 85.40741F);
((Path)localObject).close();
WeChatSVGRenderC2Java.setFillType((Path)localObject, 2);
localCanvas.drawPath((Path)localObject, localPaint);
localCanvas.restore();
c.f(paramVarArgs);
}
}
}
/* Location:
* Qualified Name: com.tencent.mm.svg.a.a.ui
* Java Class Version: 6 (50.0)
* JD-Core Version: 0.7.1
*/ | true |
60e5befe36da562e64a923a1f16cb819dd84af63 | Java | ymzyf2007/dragon-admin-mybatis | /dragon-admin-system/src/main/java/com/dragon/system/quartz/utils/ExecutionJob.java | UTF-8 | 7,266 | 1.96875 | 2 | [] | no_license | package com.dragon.system.quartz.utils;
import com.dragon.common.utils.SpringContextHolder;
import com.dragon.common.utils.ThrowableUtil;
import com.dragon.system.quartz.mapper.QuartzLogMapper;
import com.dragon.system.quartz.model.QuartzJobModel;
import com.dragon.system.quartz.model.QuartzLogModel;
import com.dragon.system.quartz.service.QuartzJobService;
import com.dragon.thread.config.ThreadPoolExecutorUtil;
import org.apache.commons.lang3.StringUtils;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.quartz.QuartzJobBean;
import java.sql.Timestamp;
import java.util.Date;
import java.util.Objects;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
@Async
public class ExecutionJob extends QuartzJobBean {
private static final Logger log = LoggerFactory.getLogger(ExecutionJob.class);
private final static ThreadPoolExecutor EXECUTOR = ThreadPoolExecutorUtil.getThreadPool();
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
QuartzJobModel quartzJob = (QuartzJobModel) context.getMergedJobDataMap().get(QuartzJobModel.JOB_KEY);
QuartzLogMapper quartzLogMapper = SpringContextHolder.getBean(QuartzLogMapper.class);
QuartzJobService quartzJobService = SpringContextHolder.getBean(QuartzJobService.class);
Date now = new Date();
QuartzLogModel logModel = new QuartzLogModel();
logModel.setJobName(quartzJob.getJobName());
logModel.setBeanName(quartzJob.getBeanName());
logModel.setMethodName(quartzJob.getMethodName());
logModel.setParams(quartzJob.getParams());
logModel.setCronExpression(quartzJob.getCronExpression());
logModel.setCreateTime(new Timestamp(now.getTime()));
long startTime = System.currentTimeMillis();
try {
log.info("ไปปๅกๅผๅงๆง่ก๏ผไปปๅกๅ็งฐ๏ผ{}", quartzJob.getJobName());
ConcreteQuartzTaskRunnable task = new ConcreteQuartzTaskRunnable(quartzJob.getBeanName(), quartzJob.getMethodName(), quartzJob.getParams());
Future<?> future = EXECUTOR.submit(task);
future.get();
long durationTime = System.currentTimeMillis() - startTime;
// ๆง่ก่ๆถ
logModel.setTime(durationTime);
// ไปปๅก็ถๆ
logModel.setIsSuccess(true);
log.info("ไปปๅกๆง่กๅฎๆฏ๏ผไปปๅกๅ็งฐ๏ผ{}๏ผๆง่กๆถ้ด๏ผ{}ๆฏซ็ง", quartzJob.getJobName(), durationTime);
} catch (Exception e) {
long durationTime = System.currentTimeMillis() - startTime;
logModel.setTime(durationTime);
// ไปปๅก็ถๆ
logModel.setIsSuccess(false);
// ๅผๅธธ่ฏฆๆ
logModel.setExceptionDetail(ThrowableUtil.getStackTrace(e));
// ไปปๅกๅฆๆๅคฑ่ดฅไบๅๆๅ
if(Objects.nonNull(quartzJob.getPauseAfterFailure()) && quartzJob.getPauseAfterFailure()) {
quartzJob.setIsPause(true);
// ๆดๆฐ็ถๆ
quartzJobService.updateIsPause(quartzJob);
}
if (StringUtils.isNotBlank(quartzJob.getEmail())) {
// IEmailService emailService = SpringContextHolder.getBean(IEmailService.class);
// // ้ฎ็ฎฑๆฅ่ญฆ
// EmailVo emailVo = taskAlarm(quartzJob, ThrowableUtil.getStackTrace(e));
// emailService.send(emailVo, emailService.find());
}
log.error("ไปปๅกๆง่กๅคฑ่ดฅ๏ผไปปๅกๅ็งฐ๏ผ{}๏ผๆง่กๆถ้ด๏ผ{}ๆฏซ็ง", quartzJob.getJobName(), durationTime, e);
} finally {
quartzLogMapper.insert(logModel);
}
}
// @Override
// protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
// QuartzJob quartzJob = (QuartzJob) context.getMergedJobDataMap().get(QuartzJob.JOB_KEY);
// // ่ทๅspring bean
// QuartzLogRepository quartzLogRepository = SpringContextHolder.getBean(QuartzLogRepository.class);
// RedisUtils redisUtils = SpringContextHolder.getBean(RedisUtils.class);
// String uuid = quartzJob.getUuid();
//
// QuartzLog quartzLog = new QuartzLog();
// quartzLog.setJobName(quartzJob.getJobName());
// quartzLog.setBeanName(quartzJob.getBeanName());
// quartzLog.setMethodName(quartzJob.getMethodName());
// quartzLog.setParams(quartzJob.getParams());
// quartzLog.setCronExpression(quartzJob.getCronExpression());
// long startTime = System.currentTimeMillis();
// try {
// log.info("ไปปๅกๅผๅงๆง่ก๏ผไปปๅกๅ็งฐ๏ผ{}", quartzJob.getJobName());
// ConcreteQuartzTaskRunnable task = new ConcreteQuartzTaskRunnable(quartzJob.getBeanName(), quartzJob.getMethodName(), quartzJob.getParams());
// Future<?> future = EXECUTOR.submit(task);
// future.get();
// long durationTime = System.currentTimeMillis() - startTime;
// quartzLog.setTime(durationTime);
// // ไปปๅก็ถๆ
// quartzLog.setIsSuccess(true);
// log.info("ไปปๅกๆง่กๅฎๆฏ๏ผไปปๅกๅ็งฐ๏ผ{}๏ผๆง่กๆถ้ด๏ผ{}ๆฏซ็ง", quartzJob.getJobName(), durationTime);
// if(StringUtils.isNotBlank(uuid)) {
// redisUtils.set(uuid, true);
// }
// // ๅคๆญๆฏๅฆๅญๅจๅญไปปๅก
// if(StringUtils.isNotEmpty(quartzJob.getSubTask())) {
// String[] tasks = quartzJob.getSubTask().split("[,๏ผ]");
//// // ๆง่กๅญไปปๅก
//// quartzJobService.executionSubJob(tasks);
// }
// } catch (Exception e) {
// if(Objects.nonNull(quartzJob.getEmail())) {
// EmailConfigService emailConfigService = SpringContextHolder.getBean(EmailConfigService.class);
// // ้ฎ็ฎฑๆฅ่ญฆ
// EmailVo emailVo = taskAlarm(quartzJob, ThrowableUtil.getStackTrace(e));
// emailConfigService.send(emailVo, emailConfigService.find());
// }
// if(StringUtils.isNotBlank(uuid)) {
// redisUtils.set(uuid, false);
// }
//
// } finally {
// quartzLogRepository.save(quartzLog);
// }
// }
//
// private EmailVo taskAlarm(QuartzJob quartzJob, String msg) {
// EmailVo emailVo = new EmailVo();
// emailVo.setSubject("ๅฎๆถไปปๅกใ"+ quartzJob.getJobName() +"ใๆง่กๅคฑ่ดฅ๏ผ่ฏทๅฐฝๅฟซๅค็๏ผ");
// Map<String, Object> data = new HashMap<>(16);
// data.put("task", quartzJob);
// data.put("msg", msg);
// TemplateEngine engine = TemplateUtil.createEngine(new TemplateConfig("template", TemplateConfig.ResourceMode.CLASSPATH));
// Template template = engine.getTemplate("email/taskAlarm.ftl");
// emailVo.setContent(template.render(data));
// List<String> emails = Arrays.asList(quartzJob.getEmail().split("[,๏ผ]"));
// emailVo.setTos(emails);
// return emailVo;
// }
}
| true |
02f2eac6ea31e867b2732967bb03fc66a1739180 | Java | lucasserain/automato-generator-api | /src/main/java/com/serainlucas/apiautomatos/models/Simbolos.java | UTF-8 | 651 | 2.484375 | 2 | [] | no_license | package com.serainlucas.apiautomatos.models;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
@Setter
@Getter
@AllArgsConstructor
public class Simbolos {
private String name;
private String estado;
public void printaIfSimbolo() {
Arquivo.setTextos("\tif(f[p] == "+"'"+this.getName()+"'" +")\n" +
"\t\t{\n" +
"\t\t\tp++;\n" +
"\t\t\t"+this.getEstado()+"();\n" +
"\t\t}\n");
}
public void printaIfSimboloGoto() {
Arquivo.setTextos("\tif(f[p] == "+"'"+this.getName()+"'" +")\n" +
"\t\t{\n" +
"\t\t\tp++;\n" +
"\t\t\tgoto "+this.getEstado()+";\n" +
"\t\t}");
}
}
| true |
410c9cdb0cd211ffae589711da88b96d8a2b27a2 | Java | semantic-conflicts/SemanticConflicts | /results/jsoup/3f7d2c71dbbbb289c684f339874eed8ac2747fa0/transformed/randoop_4/RegressionTest1.java | UTF-8 | 1,614,176 | 2.296875 | 2 | [] | no_license | import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class RegressionTest1 {
public static boolean debug = false;
@Test
public void test0501() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0501");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!=null", "hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
}
@Test
public void test0502() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0502");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry20 = request18.scanHeaders("");
boolean boolean21 = request18.followRedirects;
java.util.Map<java.lang.String, java.lang.String> strMap22 = request18.cookies();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection23 = request18.data;
boolean boolean25 = request18.hasCookie("null=null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
}
@Test
public void test0503() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0503");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
java.net.URL uRL7 = request0.url();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = request0.scanHeaders("null=null");
org.jsoup.Connection.Request request11 = request0.followRedirects(true);
int int12 = request0.maxBodySizeBytes;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
}
@Test
public void test0504() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0504");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.lang.String str14 = request8.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
org.jsoup.Connection.Request request17 = request8.method(method16);
org.jsoup.Connection.Request request18 = request6.method(method16);
boolean boolean20 = request6.hasHeader("hi!");
org.jsoup.Connection.Request request22 = request6.removeCookie("");
httpConnection0.req = request22;
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request25 = null;
org.jsoup.Connection connection26 = httpConnection24.request(request25);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection connection29 = httpConnection24.response(response28);
httpConnection0.res = response28;
org.jsoup.Connection connection32 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
java.util.Map<java.lang.String, java.lang.String> strMap35 = request33.headers();
java.util.Map<java.lang.String, java.lang.String> strMap36 = request33.headers();
org.jsoup.Connection.Method method37 = request33.method();
org.jsoup.Connection connection38 = httpConnection0.method(method37);
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
boolean boolean41 = request39.followRedirects;
org.jsoup.Connection.Request request43 = request39.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap44 = request39.headers();
boolean boolean45 = request39.ignoreContentType;
request39.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap48 = request39.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap49 = request39.cookies();
java.lang.String str51 = request39.getHeaderCaseInsensitive("null=null");
org.jsoup.helper.HttpConnection.Request request53 = request39.timeout(0);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection54 = request39.data();
org.jsoup.Connection connection55 = httpConnection0.data(keyValCollection54);
org.jsoup.Connection connection57 = httpConnection0.maxBodySize((int) (byte) 100);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap36);
org.junit.Assert.assertTrue("'" + method37 + "' != '" + org.jsoup.Connection.Method.GET + "'", method37.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection38);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean41 + "' != '" + true + "'", boolean41 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + false + "'", boolean45 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
}
@Test
public void test0505() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0505");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
response1.statusCode = (short) -1;
java.util.Map<java.lang.String, java.lang.String> strMap9 = response1.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
boolean boolean17 = request10.followRedirects();
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
org.jsoup.Connection.Request request20 = request10.method(method19);
org.jsoup.Connection.Response response21 = response1.method(method19);
int int22 = response1.numRedirects;
org.jsoup.Connection.Method method23 = response1.method();
int int24 = response1.statusCode;
java.lang.String str25 = response1.contentType();
java.net.HttpURLConnection httpURLConnection26 = null;
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request28 = null;
org.jsoup.Connection connection29 = httpConnection27.request(request28);
org.jsoup.helper.HttpConnection httpConnection30 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response31 = httpConnection30.response();
org.jsoup.Connection.Request request32 = httpConnection30.request();
org.jsoup.Connection connection33 = httpConnection27.request(request32);
org.jsoup.Connection.Response response34 = httpConnection27.response();
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection26, response34);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 0 + "'", int22 == 0);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int24 + "' != '" + (-1) + "'", int24 == (-1));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str25 + "' != '" + "null=null=null=hi!" + "'", str25.equals("null=null=null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response34);
}
@Test
public void test0506() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0506");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal0.value("hi!");
java.lang.String str7 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal0.value("null=null");
java.lang.String str10 = keyVal9.value();
java.lang.String str11 = keyVal9.value;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str10 + "' != '" + "null=null" + "'", str10.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str11 + "' != '" + "null=null" + "'", str11.equals("null=null"));
}
@Test
public void test0507() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0507");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("hi!=", "null=null");
}
@Test
public void test0508() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0508");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Request request4 = null;
httpConnection0.req = request4;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
boolean boolean10 = request6.hasCookie("null=null");
org.jsoup.Connection connection11 = httpConnection0.request((org.jsoup.Connection.Request) request6);
java.net.URL uRL12 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection13 = httpConnection0.url(uRL12);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
}
@Test
public void test0509() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0509");
org.jsoup.helper.HttpConnection.Response.MAX_REDIRECTS = '#';
}
@Test
public void test0510() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0510");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
org.jsoup.Connection.Request request12 = request7.cookie("null=null=null=hi!", "hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
}
@Test
public void test0511() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0511");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.toString();
keyVal0.value = "";
keyVal0.value = "null=hi!";
keyVal0.key = "null=null";
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal0.key("hi!");
java.lang.String str10 = keyVal0.value();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "null=null" + "'", str1.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str10 + "' != '" + "null=hi!" + "'", str10.equals("null=hi!"));
}
@Test
public void test0512() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0512");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection connection8 = httpConnection0.ignoreContentType(true);
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document9 = httpConnection0.post();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
}
@Test
public void test0513() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0513");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal0.value("hi!");
java.lang.String str7 = keyVal0.key();
keyVal0.value = "hi!=";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
}
@Test
public void test0514() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0514");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response18 = response1.cookie("", "null=null");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Cookie name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
}
@Test
public void test0515() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0515");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.lang.String str2 = response1.contentType();
java.lang.String str3 = response1.contentType();
response1.numRedirects = 1;
// The following exception was thrown during execution in test generation
try {
boolean boolean7 = response1.hasHeader("");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str3);
}
@Test
public void test0516() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0516");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection10 = request7.data();
java.lang.String str12 = request7.header("hi!");
org.jsoup.Connection.Request request15 = request7.header("null=null=hi!", "");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = request7.scanHeaders("null=null=null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap18 = request7.headers();
java.lang.Class<?> wildcardClass19 = request7.getClass();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(wildcardClass19);
}
@Test
public void test0517() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0517");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal0.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal0.value("null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
}
@Test
public void test0518() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0518");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal3.key("hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
}
@Test
public void test0519() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0519");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
response1.statusCode = (short) -1;
java.util.Map<java.lang.String, java.lang.String> strMap9 = response1.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
boolean boolean17 = request10.followRedirects();
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
org.jsoup.Connection.Request request20 = request10.method(method19);
org.jsoup.Connection.Response response21 = response1.method(method19);
java.lang.String str22 = response1.charset();
org.jsoup.Connection.Method method23 = response1.method();
boolean boolean24 = response1.executed;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
}
@Test
public void test0520() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0520");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
boolean boolean5 = response1.executed;
response1.executed = true;
org.jsoup.Connection.Method method8 = response1.method();
org.jsoup.Connection.Request request9 = response1.req;
// The following exception was thrown during execution in test generation
try {
byte[] byteArray10 = response1.bodyAsBytes();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request9);
}
@Test
public void test0521() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0521");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection10 = request7.data();
boolean boolean12 = request7.hasCookie("");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
}
@Test
public void test0522() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0522");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean9 = request3.hasCookie("null=null");
java.lang.String str11 = request3.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection connection12 = httpConnection0.request((org.jsoup.Connection.Request) request3);
org.jsoup.Connection connection15 = httpConnection0.data("null=hi!", "");
org.jsoup.Connection connection17 = httpConnection0.maxBodySize(32);
org.jsoup.Connection.Request request18 = httpConnection0.request();
org.jsoup.Connection connection20 = httpConnection0.followRedirects(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
}
@Test
public void test0523() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0523");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
org.jsoup.Connection.Method method2 = response1.method();
boolean boolean4 = response1.hasCookie("");
java.net.HttpURLConnection httpURLConnection5 = null;
org.jsoup.helper.HttpConnection.Response response6 = null;
org.jsoup.helper.HttpConnection.Response response7 = new org.jsoup.helper.HttpConnection.Response(response6);
int int8 = response7.statusCode();
int int9 = response7.numRedirects;
java.lang.String str10 = response7.charset;
java.net.URL uRL11 = response7.url();
response7.charset = "hi!=null";
org.jsoup.Connection.Response response16 = response7.cookie("null=null=hi!", "hi!=null");
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection5, (org.jsoup.Connection.Response) response7);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response16);
}
@Test
public void test0524() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0524");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
request0.maxBodySizeBytes = (-1);
java.lang.String str4 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Response response5 = null;
org.jsoup.helper.HttpConnection.Response response6 = new org.jsoup.helper.HttpConnection.Response(response5);
int int7 = response6.statusCode();
int int8 = response6.numRedirects;
java.lang.String str9 = response6.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry11 = response6.scanHeaders("");
java.net.URL uRL12 = response6.url();
response6.statusCode = 10;
response6.executed = true;
java.util.Map<java.lang.String, java.lang.String> strMap17 = response6.cookies();
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response18 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request0, response6);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
}
@Test
public void test0525() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0525");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("null=", "null=null=null=hi!");
java.lang.String str3 = keyVal2.key();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "null=" + "'", str3.equals("null="));
}
@Test
public void test0526() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0526");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
request0.followRedirects = false;
boolean boolean17 = request0.ignoreContentType();
org.jsoup.helper.HttpConnection httpConnection18 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response19 = httpConnection18.response();
org.jsoup.Connection connection21 = httpConnection18.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection22 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection25 = httpConnection22.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
int int29 = request26.timeout();
org.jsoup.parser.Parser parser30 = request26.parser();
org.jsoup.Connection connection31 = httpConnection22.parser(parser30);
org.jsoup.Connection connection32 = httpConnection18.parser(parser30);
org.jsoup.helper.HttpConnection.Request request33 = request0.parser(parser30);
boolean boolean34 = request0.followRedirects;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int29 + "' != '" + 3000 + "'", int29 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + false + "'", boolean34 == false);
}
@Test
public void test0527() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0527");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection.Request request7 = httpConnection0.req;
org.jsoup.Connection connection9 = httpConnection0.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
request10.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap19 = request10.cookies();
httpConnection0.req = request10;
boolean boolean22 = request10.hasCookie("null=null=null=hi!");
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response23 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request10);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
}
@Test
public void test0528() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0528");
org.jsoup.helper.HttpConnection.HTTP_TEMP_REDIR = 'a';
}
@Test
public void test0529() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0529");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
org.jsoup.Connection.Request request7 = response1.req;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = response1.scanHeaders("hi!=null");
java.util.Map<java.lang.String, java.lang.String> strMap10 = response1.headers();
java.net.URL uRL11 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response12 = response1.url(uRL11);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
}
@Test
public void test0530() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0530");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
java.lang.String str4 = response1.header("hi!=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
}
@Test
public void test0531() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0531");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
response1.statusMessage = "hi!=null";
int int10 = response1.numRedirects;
org.jsoup.Connection.Method method11 = response1.method();
org.jsoup.Connection.Response response14 = response1.header("null=", "null=null=null=hi!=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 0 + "'", int10 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response14);
}
@Test
public void test0532() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0532");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request9 = request0.timeout((int) (byte) 0);
boolean boolean11 = request0.hasHeader("null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
}
@Test
public void test0533() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0533");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
org.jsoup.Connection.Request request8 = request0.maxBodySize((int) (byte) 0);
org.jsoup.Connection.Request request10 = request0.removeCookie("hi!");
boolean boolean11 = request0.followRedirects();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + true + "'", boolean11 == true);
}
@Test
public void test0534() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0534");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
int int12 = request7.maxBodySize();
java.lang.String str14 = request7.header("hi!");
boolean boolean15 = request7.followRedirects();
java.net.URL uRL16 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request17 = request7.url(uRL16);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
}
@Test
public void test0535() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0535");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.net.URL uRL9 = request0.url();
org.jsoup.Connection.Request request11 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request13 = request0.removeCookie("null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
}
@Test
public void test0536() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0536");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
int int7 = request0.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap13 = request8.headers();
boolean boolean14 = request8.ignoreContentType;
boolean boolean15 = request8.followRedirects();
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
org.jsoup.Connection.Request request18 = request8.method(method17);
org.jsoup.Connection.Request request19 = request0.method(method17);
java.lang.String str20 = org.jsoup.helper.HttpConnection.Response.getRequestCookieString((org.jsoup.Connection.Request) request0);
org.jsoup.Connection.Request request23 = request0.header("null=null", "hi!=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 1048576 + "'", int7 == 1048576);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str20 + "' != '" + "" + "'", str20.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
}
@Test
public void test0537() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0537");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
org.jsoup.helper.HttpConnection.Request request4 = request0.timeout(1048576);
boolean boolean5 = request0.ignoreContentType;
request0.timeoutMilliseconds = (byte) -1;
org.jsoup.Connection.Request request9 = request0.maxBodySize((int) (byte) 1);
org.jsoup.helper.HttpConnection httpConnection10 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request11 = null;
org.jsoup.Connection connection12 = httpConnection10.request(request11);
org.jsoup.helper.HttpConnection httpConnection13 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response14 = httpConnection13.response();
org.jsoup.Connection.Request request15 = httpConnection13.request();
org.jsoup.Connection connection16 = httpConnection10.request(request15);
org.jsoup.Connection.Request request17 = httpConnection10.req;
org.jsoup.Connection connection19 = httpConnection10.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
boolean boolean22 = request20.followRedirects;
org.jsoup.Connection.Request request24 = request20.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap25 = request20.headers();
boolean boolean26 = request20.ignoreContentType;
request20.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap29 = request20.cookies();
httpConnection10.req = request20;
boolean boolean32 = request20.hasCookie("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
java.util.Map<java.lang.String, java.lang.String> strMap35 = request33.headers();
request33.followRedirects = false;
boolean boolean38 = request33.ignoreHttpErrors;
org.jsoup.Connection.Method method39 = request33.method();
int int40 = request33.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request41 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method42 = request41.method();
boolean boolean43 = request41.followRedirects;
org.jsoup.Connection.Request request45 = request41.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap46 = request41.headers();
boolean boolean47 = request41.ignoreContentType;
boolean boolean48 = request41.followRedirects();
org.jsoup.helper.HttpConnection.Request request49 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method50 = request49.method();
org.jsoup.Connection.Request request51 = request41.method(method50);
org.jsoup.Connection.Request request52 = request33.method(method50);
org.jsoup.Connection.Request request53 = request20.method(method50);
org.jsoup.Connection.Request request54 = request0.method(method50);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + true + "'", boolean22 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + false + "'", boolean26 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + false + "'", boolean38 == false);
org.junit.Assert.assertTrue("'" + method39 + "' != '" + org.jsoup.Connection.Method.GET + "'", method39.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 1048576 + "'", int40 == 1048576);
org.junit.Assert.assertTrue("'" + method42 + "' != '" + org.jsoup.Connection.Method.GET + "'", method42.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + true + "'", boolean43 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean48 + "' != '" + true + "'", boolean48 == true);
org.junit.Assert.assertTrue("'" + method50 + "' != '" + org.jsoup.Connection.Method.GET + "'", method50.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request54);
}
@Test
public void test0538() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0538");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection19 = httpConnection0.referrer("hi!");
org.jsoup.Connection connection21 = httpConnection0.referrer("null=null=null=hi!");
org.jsoup.Connection.Response response22 = null;
org.jsoup.Connection connection23 = httpConnection0.response(response22);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response24 = httpConnection0.execute();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
}
@Test
public void test0539() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0539");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
org.jsoup.Connection.Request request9 = request0.method(method8);
java.net.URL uRL10 = request0.url();
java.lang.String str12 = request0.cookie("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
java.util.Map<java.lang.String, java.lang.String> strMap15 = request13.headers();
request13.followRedirects = false;
boolean boolean18 = request13.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request20 = request13.timeout((int) ' ');
boolean boolean21 = request20.ignoreContentType;
boolean boolean22 = request20.followRedirects();
org.jsoup.helper.HttpConnection.Request request23 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method24 = request23.method();
java.util.Map<java.lang.String, java.lang.String> strMap25 = request23.headers();
request23.followRedirects = false;
java.lang.String str29 = request23.cookie("");
boolean boolean30 = request23.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.followRedirects = false;
boolean boolean36 = request31.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection37 = request31.data();
request23.data = keyValCollection37;
request20.data = keyValCollection37;
request0.data = keyValCollection37;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + false + "'", boolean18 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
org.junit.Assert.assertTrue("'" + method24 + "' != '" + org.jsoup.Connection.Method.GET + "'", method24.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean30 + "' != '" + false + "'", boolean30 == false);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + false + "'", boolean36 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection37);
}
@Test
public void test0540() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0540");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
org.jsoup.Connection.Request request8 = request0.followRedirects(false);
java.lang.String str10 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
java.util.Map<java.lang.String, java.lang.String> strMap13 = request11.headers();
request11.followRedirects = false;
boolean boolean16 = request11.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request18 = request11.timeout((int) ' ');
java.lang.String str20 = request18.cookie("hi!");
java.lang.String str22 = request18.header("null=null");
request18.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser30 = request25.parser;
request18.parser = parser30;
request0.parser = parser30;
int int33 = request0.timeoutMilliseconds;
org.jsoup.Connection.Request request35 = request0.maxBodySize((int) (byte) 10);
org.jsoup.helper.HttpConnection httpConnection36 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response37 = httpConnection36.response();
org.jsoup.Connection.Request request38 = httpConnection36.request();
org.jsoup.Connection.Request request39 = httpConnection36.req;
org.jsoup.Connection.Request request40 = httpConnection36.request();
org.jsoup.Connection.Response response41 = httpConnection36.res;
org.jsoup.helper.HttpConnection.Request request42 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method43 = request42.method();
org.jsoup.helper.HttpConnection.Request request44 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method45 = request44.method();
boolean boolean46 = request44.followRedirects;
org.jsoup.Connection.Request request48 = request44.followRedirects(true);
java.lang.String str50 = request44.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
org.jsoup.Connection.Request request53 = request44.method(method52);
org.jsoup.Connection.Request request54 = request42.method(method52);
boolean boolean56 = request42.hasHeader("hi!");
org.jsoup.Connection.Request request58 = request42.removeCookie("");
httpConnection36.req = request58;
org.jsoup.helper.HttpConnection httpConnection60 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request61 = null;
org.jsoup.Connection connection62 = httpConnection60.request(request61);
org.jsoup.helper.HttpConnection httpConnection63 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response64 = httpConnection63.response();
org.jsoup.Connection connection65 = httpConnection60.response(response64);
httpConnection36.res = response64;
org.jsoup.Connection connection68 = httpConnection36.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request69 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method70 = request69.method();
java.util.Map<java.lang.String, java.lang.String> strMap71 = request69.headers();
java.util.Map<java.lang.String, java.lang.String> strMap72 = request69.headers();
org.jsoup.Connection.Method method73 = request69.method();
org.jsoup.Connection connection74 = httpConnection36.method(method73);
org.jsoup.Connection.Request request75 = request0.method(method73);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 3000 + "'", int33 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response41);
org.junit.Assert.assertTrue("'" + method43 + "' != '" + org.jsoup.Connection.Method.GET + "'", method43.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method45 + "' != '" + org.jsoup.Connection.Method.GET + "'", method45.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean46 + "' != '" + true + "'", boolean46 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str50);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + false + "'", boolean56 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection68);
org.junit.Assert.assertTrue("'" + method70 + "' != '" + org.jsoup.Connection.Method.GET + "'", method70.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap72);
org.junit.Assert.assertTrue("'" + method73 + "' != '" + org.jsoup.Connection.Method.GET + "'", method73.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request75);
}
@Test
public void test0541() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0541");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.ignoreHttpErrors();
org.jsoup.Connection.Request request16 = request11.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
boolean boolean22 = request17.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request24 = request17.timeout((int) ' ');
java.lang.String str26 = request24.cookie("hi!");
java.lang.String str28 = request24.header("null=null");
request24.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser36 = request31.parser;
request24.parser = parser36;
org.jsoup.helper.HttpConnection.Request request38 = request11.parser(parser36);
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request38.method(method40);
org.jsoup.Connection.Request request42 = request6.method(method40);
org.jsoup.Connection.Response response43 = response1.method(method40);
org.jsoup.helper.HttpConnection.Response response44 = new org.jsoup.helper.HttpConnection.Response(response1);
// The following exception was thrown during execution in test generation
try {
byte[] byteArray45 = response44.bodyAsBytes();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before getting response body");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str28);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
}
@Test
public void test0542() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0542");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.Connection connection6 = httpConnection0.header("null=null=null=hi!", "");
org.jsoup.Connection connection9 = httpConnection0.cookie("null=null=hi!", "null=hi!");
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request10.headers();
java.util.Map<java.lang.String, java.lang.String> strMap13 = request10.headers();
org.jsoup.helper.HttpConnection.KeyVal keyVal14 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str15 = keyVal14.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal17 = keyVal14.value("hi!");
java.lang.String str18 = keyVal14.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = keyVal14.value("hi!");
java.lang.String str21 = keyVal14.key();
org.jsoup.helper.HttpConnection.Request request22 = request10.data((org.jsoup.Connection.KeyVal) keyVal14);
java.net.URL uRL23 = request22.url();
org.jsoup.Connection connection24 = httpConnection0.request((org.jsoup.Connection.Request) request22);
org.jsoup.Connection.Method method25 = request22.method();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
}
@Test
public void test0543() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0543");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
org.jsoup.Connection.Request request8 = request0.followRedirects(false);
java.lang.String str10 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.followRedirects;
org.jsoup.Connection.Request request15 = request11.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap16 = request11.headers();
boolean boolean17 = request11.ignoreContentType;
request11.maxBodySizeBytes = (short) 100;
org.jsoup.parser.Parser parser20 = request11.parser;
org.jsoup.helper.HttpConnection.Request request21 = request0.parser(parser20);
java.lang.String str23 = request0.header("hi!=null");
boolean boolean24 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
boolean boolean27 = request25.followRedirects;
org.jsoup.Connection.Request request29 = request25.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap30 = request25.cookies();
boolean boolean32 = request25.hasCookie("");
org.jsoup.helper.HttpConnection.KeyVal keyVal33 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str34 = keyVal33.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal36 = keyVal33.value("hi!");
java.lang.String str37 = keyVal33.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = keyVal33.value("hi!");
java.lang.String str40 = keyVal33.key();
org.jsoup.helper.HttpConnection.Request request41 = request25.data((org.jsoup.Connection.KeyVal) keyVal33);
org.jsoup.helper.HttpConnection.Request request42 = request0.data((org.jsoup.Connection.KeyVal) keyVal33);
java.lang.String str44 = request42.getHeaderCaseInsensitive("hi!");
org.jsoup.Connection.Request request46 = request42.followRedirects(true);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + true + "'", boolean13 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + true + "'", boolean27 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
}
@Test
public void test0544() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0544");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
org.jsoup.Connection.Method method2 = response1.method();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry4 = response1.scanHeaders("null=hi!");
org.jsoup.Connection.Method method5 = response1.method();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method5);
}
@Test
public void test0545() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0545");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
boolean boolean6 = request0.followRedirects();
request0.ignoreHttpErrors = false;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + true + "'", boolean6 == true);
}
@Test
public void test0546() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0546");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.charset;
org.jsoup.Connection.Response response8 = response1.header("null=", "hi!");
int int9 = response1.statusCode();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
}
@Test
public void test0547() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0547");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
java.net.URL uRL8 = request0.url();
java.lang.String str10 = request0.header("null=null=hi!");
boolean boolean12 = request0.hasCookie("hi!");
boolean boolean14 = request0.hasHeader("null=");
boolean boolean15 = request0.followRedirects();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
}
@Test
public void test0548() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0548");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection.Response response7 = httpConnection0.response();
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection9 = httpConnection0.url("hi!");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Malformed URL: hi!");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response7);
}
@Test
public void test0549() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0549");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.followRedirects();
org.jsoup.helper.HttpConnection.Request request10 = request7.timeout((int) '4');
org.jsoup.Connection.Method method11 = request7.method();
java.net.URL uRL12 = request7.url();
java.net.URL uRL13 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request14 = request7.url(uRL13);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL12);
}
@Test
public void test0550() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0550");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.lang.String str2 = response1.statusMessage();
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean8 = request3.ignoreHttpErrors;
org.jsoup.Connection.Method method9 = request3.method();
int int10 = request3.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.followRedirects;
org.jsoup.Connection.Request request15 = request11.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap16 = request11.headers();
boolean boolean17 = request11.ignoreContentType;
boolean boolean18 = request11.followRedirects();
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
org.jsoup.Connection.Request request21 = request11.method(method20);
org.jsoup.Connection.Request request22 = request3.method(method20);
org.jsoup.Connection.Response response23 = response1.method(method20);
java.lang.String str24 = response1.contentType();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 1048576 + "'", int10 == 1048576);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + true + "'", boolean13 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + true + "'", boolean18 == true);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str24);
}
@Test
public void test0551() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0551");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
org.jsoup.Connection.Request request16 = request0.removeCookie("");
java.net.URL uRL17 = request0.url();
org.jsoup.Connection.Request request19 = request0.maxBodySize(10);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
}
@Test
public void test0552() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0552");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!=null", "hi!=null");
java.lang.String str3 = keyVal2.toString();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "hi!=null=hi!=null" + "'", str3.equals("hi!=null=hi!=null"));
}
@Test
public void test0553() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0553");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
boolean boolean6 = request0.hasHeader("hi!=null");
request0.maxBodySizeBytes = 1048576;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
}
@Test
public void test0554() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0554");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection connection9 = httpConnection0.cookie("null=null", "null=null");
org.jsoup.Connection connection11 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
boolean boolean14 = request12.followRedirects;
org.jsoup.Connection.Request request16 = request12.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap17 = request12.cookies();
org.jsoup.Connection connection18 = httpConnection0.data(strMap17);
org.jsoup.Connection connection21 = httpConnection0.data("null=hi!", "hi!=null=hi!=null");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response22 = httpConnection0.execute();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + true + "'", boolean14 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
}
@Test
public void test0555() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0555");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.statusMessage;
java.util.Map<java.lang.String, java.lang.String> strMap6 = response1.headers();
java.lang.String str7 = response1.charset;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
}
@Test
public void test0556() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0556");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean9 = request3.hasCookie("null=null");
java.lang.String str11 = request3.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection connection12 = httpConnection0.request((org.jsoup.Connection.Request) request3);
org.jsoup.helper.HttpConnection httpConnection13 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response14 = httpConnection13.response();
httpConnection0.res = response14;
org.jsoup.Connection.Response response16 = httpConnection0.response();
java.net.URL uRL17 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection18 = httpConnection0.url(uRL17);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response16);
}
@Test
public void test0557() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0557");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap1 = request0.headers();
java.lang.Class<?> wildcardClass2 = request0.getClass();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(wildcardClass2);
}
@Test
public void test0558() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0558");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request0.followRedirects();
org.jsoup.Connection.Request request10 = request0.removeHeader("null=null=null=hi!");
org.jsoup.Connection.Request request12 = request0.ignoreContentType(false);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection13 = request0.data;
java.net.URL uRL14 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request15 = request0.url(uRL14);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection13);
}
@Test
public void test0559() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0559");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
response1.statusMessage = "null=";
int int7 = response1.statusCode;
response1.contentType = "";
java.net.HttpURLConnection httpURLConnection10 = null;
org.jsoup.helper.HttpConnection.Response response11 = null;
org.jsoup.helper.HttpConnection.Response response12 = new org.jsoup.helper.HttpConnection.Response(response11);
int int13 = response12.statusCode();
int int14 = response12.numRedirects;
response12.charset = "";
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request22 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method23 = request22.method();
boolean boolean24 = request22.ignoreHttpErrors();
org.jsoup.Connection.Request request27 = request22.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request28 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method29 = request28.method();
java.util.Map<java.lang.String, java.lang.String> strMap30 = request28.headers();
request28.followRedirects = false;
boolean boolean33 = request28.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request35 = request28.timeout((int) ' ');
java.lang.String str37 = request35.cookie("hi!");
java.lang.String str39 = request35.header("null=null");
request35.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request42 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method43 = request42.method();
java.util.Map<java.lang.String, java.lang.String> strMap44 = request42.headers();
request42.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser47 = request42.parser;
request35.parser = parser47;
org.jsoup.helper.HttpConnection.Request request49 = request22.parser(parser47);
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
org.jsoup.Connection.Request request52 = request49.method(method51);
org.jsoup.Connection.Request request53 = request17.method(method51);
org.jsoup.Connection.Response response54 = response12.method(method51);
org.jsoup.Connection.Request request55 = response12.req;
response12.statusCode = (byte) 10;
response12.charset = "null=";
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection10, (org.jsoup.Connection.Response) response12);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 0 + "'", int13 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str39);
org.junit.Assert.assertTrue("'" + method43 + "' != '" + org.jsoup.Connection.Method.GET + "'", method43.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request49);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request55);
}
@Test
public void test0560() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0560");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
java.lang.String str15 = request13.cookie("hi!");
java.lang.String str17 = request13.header("null=null");
request13.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
java.util.Map<java.lang.String, java.lang.String> strMap22 = request20.headers();
request20.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser25 = request20.parser;
request13.parser = parser25;
org.jsoup.helper.HttpConnection.Request request27 = request0.parser(parser25);
boolean boolean28 = request0.ignoreHttpErrors();
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response30 = httpConnection29.response();
org.jsoup.Connection connection32 = httpConnection29.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection33 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection36 = httpConnection33.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
int int40 = request37.timeout();
org.jsoup.parser.Parser parser41 = request37.parser();
org.jsoup.Connection connection42 = httpConnection33.parser(parser41);
org.jsoup.Connection connection43 = httpConnection29.parser(parser41);
org.jsoup.helper.HttpConnection.Request request44 = request0.parser(parser41);
int int45 = request44.timeout();
java.lang.String str47 = request44.header("hi!=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 3000 + "'", int40 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 3000 + "'", int45 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str47);
}
@Test
public void test0561() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0561");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreHttpErrors;
org.jsoup.Connection.Method method9 = request7.method();
org.jsoup.Connection.Request request12 = request7.header("hi!=null", "null=null=null=hi!");
boolean boolean13 = request7.followRedirects;
request7.timeoutMilliseconds = (short) -1;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
}
@Test
public void test0562() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0562");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = response1.scanHeaders("null=");
response1.charset = "hi!=";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
}
@Test
public void test0563() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0563");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean8 = request3.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request10 = request3.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry12 = request3.scanHeaders("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap13 = request3.headers();
org.jsoup.Connection connection14 = httpConnection0.data(strMap13);
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
java.util.Map<java.lang.String, java.lang.String> strMap17 = request15.headers();
request15.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser20 = request15.parser;
org.jsoup.Connection.Request request22 = request15.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap23 = request15.headers();
java.util.Map<java.lang.String, java.lang.String> strMap24 = request15.cookies();
org.jsoup.Connection connection25 = httpConnection0.data(strMap24);
org.jsoup.Connection connection28 = httpConnection0.header("null=null", "");
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request30 = null;
org.jsoup.Connection connection31 = httpConnection29.request(request30);
org.jsoup.helper.HttpConnection httpConnection32 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response33 = httpConnection32.response();
org.jsoup.Connection.Request request34 = httpConnection32.request();
org.jsoup.Connection connection35 = httpConnection29.request(request34);
org.jsoup.Connection connection37 = httpConnection29.ignoreContentType(true);
org.jsoup.Connection.Request request38 = httpConnection29.req;
httpConnection0.req = request38;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
}
@Test
public void test0564() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0564");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection9 = httpConnection7.followRedirects(false);
org.jsoup.Connection connection11 = httpConnection7.referrer("");
org.jsoup.Connection.Response response12 = httpConnection7.response();
org.jsoup.Connection connection13 = httpConnection0.response(response12);
org.jsoup.Connection connection15 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection17 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Request request18 = null;
org.jsoup.Connection connection19 = httpConnection0.request(request18);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection21 = httpConnection0.timeout(32);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
}
@Test
public void test0565() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0565");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
java.lang.String str8 = request0.cookie("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection9 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response10 = httpConnection9.response();
org.jsoup.Connection connection12 = httpConnection9.followRedirects(false);
org.jsoup.Connection connection14 = httpConnection9.ignoreHttpErrors(true);
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
java.util.Map<java.lang.String, java.lang.String> strMap17 = request15.headers();
request15.followRedirects = false;
boolean boolean20 = request15.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request22 = request15.timeout((int) ' ');
boolean boolean23 = request22.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal26 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal26.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal29 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal32 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal34 = keyVal32.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal35.key = "hi!";
java.lang.String str38 = keyVal35.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal40 = keyVal35.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal43 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal44 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal44.key = "hi!";
java.lang.String str47 = keyVal44.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal48 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str49 = keyVal48.toString();
keyVal48.value = "";
keyVal48.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal54 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal54.key = "hi!";
java.lang.String str57 = keyVal54.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal59 = keyVal54.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal60 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str61 = keyVal60.key();
org.jsoup.Connection.KeyVal[] keyValArray62 = new org.jsoup.Connection.KeyVal[] { keyVal26, keyVal29, keyVal34, keyVal35, keyVal43, keyVal44, keyVal48, keyVal54, keyVal60 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList63 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean64 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList63, keyValArray62);
request22.data = keyValList63;
org.jsoup.Connection connection66 = httpConnection9.data((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList63);
request0.data = keyValList63;
org.jsoup.Connection.Request request69 = request0.removeCookie("hi!=null");
java.net.URL uRL70 = request0.url();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str38 + "' != '" + "hi!" + "'", str38.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str47 + "' != '" + "hi!" + "'", str47.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str49 + "' != '" + "null=null" + "'", str49.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str57 + "' != '" + "hi!" + "'", str57.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean64 + "' != '" + true + "'", boolean64 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection66);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request69);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL70);
}
@Test
public void test0566() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0566");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection.Request request7 = httpConnection0.req;
org.jsoup.Connection connection9 = httpConnection0.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
request10.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap19 = request10.cookies();
httpConnection0.req = request10;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection21 = request10.data;
org.jsoup.Connection.Method method22 = request10.method();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection21);
org.junit.Assert.assertTrue("'" + method22 + "' != '" + org.jsoup.Connection.Method.GET + "'", method22.equals(org.jsoup.Connection.Method.GET));
}
@Test
public void test0567() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0567");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection19 = httpConnection0.referrer("hi!");
org.jsoup.helper.HttpConnection httpConnection20 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response21 = httpConnection20.response();
org.jsoup.Connection connection23 = httpConnection20.followRedirects(false);
org.jsoup.Connection.Response response24 = httpConnection20.response();
httpConnection0.res = response24;
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
java.util.Map<java.lang.String, java.lang.String> strMap29 = request26.headers();
org.jsoup.Connection.Method method30 = request26.method();
org.jsoup.Connection connection31 = httpConnection0.method(method30);
org.jsoup.Connection.Request request32 = httpConnection0.request();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response24);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap29);
org.junit.Assert.assertTrue("'" + method30 + "' != '" + org.jsoup.Connection.Method.GET + "'", method30.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request32);
}
@Test
public void test0568() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0568");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.parser.Parser parser3 = null;
org.jsoup.Connection connection4 = httpConnection0.parser(parser3);
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry11 = request6.scanHeaders("hi!");
java.util.Map<java.lang.String, java.lang.String> strMap12 = request6.headers();
org.jsoup.Connection connection13 = httpConnection0.data(strMap12);
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document14 = httpConnection0.get();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
}
@Test
public void test0569() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0569");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry20 = request18.scanHeaders("");
boolean boolean21 = request18.followRedirects;
java.util.Map<java.lang.String, java.lang.String> strMap22 = request18.cookies();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection23 = request18.data;
java.io.OutputStream outputStream24 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response.writePost(keyValCollection23, outputStream24);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection23);
}
@Test
public void test0570() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0570");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.Connection connection8 = httpConnection0.userAgent("null=null");
org.jsoup.helper.HttpConnection.Response response9 = null;
org.jsoup.helper.HttpConnection.Response response10 = new org.jsoup.helper.HttpConnection.Response(response9);
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
boolean boolean15 = request13.followRedirects;
org.jsoup.Connection.Request request17 = request13.followRedirects(true);
java.lang.String str19 = request13.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
org.jsoup.Connection.Request request22 = request13.method(method21);
org.jsoup.Connection.Request request23 = request11.method(method21);
org.jsoup.helper.HttpConnection.KeyVal keyVal24 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str25 = keyVal24.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal27 = keyVal24.value("");
java.lang.String str28 = keyVal24.value();
org.jsoup.helper.HttpConnection.Request request29 = request11.data((org.jsoup.Connection.KeyVal) keyVal24);
int int30 = request29.timeout();
response10.req = request29;
httpConnection0.res = response10;
int int33 = response10.numRedirects;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str25 + "' != '" + "null=null" + "'", str25.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str28 + "' != '" + "" + "'", str28.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 3000 + "'", int30 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 0 + "'", int33 == 0);
}
@Test
public void test0571() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0571");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
request7.followRedirects = false;
org.jsoup.parser.Parser parser14 = request7.parser;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Request request16 = request7.timeout((int) (short) -1);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Timeout milliseconds must be 0 (infinite) or greater");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser14);
}
@Test
public void test0572() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0572");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
org.jsoup.Connection.Request request16 = request0.removeCookie("");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection17 = request0.data();
org.jsoup.Connection.Request request20 = request0.header("null=hi!", "");
org.jsoup.helper.HttpConnection httpConnection21 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response22 = httpConnection21.response();
org.jsoup.Connection connection24 = httpConnection21.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection25 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response26 = httpConnection25.response();
httpConnection21.res = response26;
org.jsoup.helper.HttpConnection.Request request28 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method29 = request28.method();
java.util.Map<java.lang.String, java.lang.String> strMap30 = request28.headers();
request28.followRedirects = false;
boolean boolean33 = request28.ignoreHttpErrors;
org.jsoup.Connection.Method method34 = request28.method();
org.jsoup.Connection connection35 = httpConnection21.method(method34);
org.jsoup.Connection.Request request36 = request0.method(method34);
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
boolean boolean39 = request37.ignoreHttpErrors();
org.jsoup.Connection.Request request42 = request37.cookie("hi!", "");
boolean boolean43 = request37.ignoreContentType;
org.jsoup.Connection.Request request46 = request37.cookie("null=hi!", "hi!");
java.lang.String str48 = request37.getHeaderCaseInsensitive("");
java.lang.String str50 = request37.cookie("");
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
java.util.Map<java.lang.String, java.lang.String> strMap53 = request51.headers();
request51.followRedirects = false;
boolean boolean56 = request51.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request58 = request51.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry60 = request51.scanHeaders("null=null");
org.jsoup.Connection.Request request62 = request51.ignoreContentType(false);
org.jsoup.helper.HttpConnection.Request request63 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method64 = request63.method();
boolean boolean65 = request63.ignoreHttpErrors();
org.jsoup.Connection.Request request68 = request63.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request69 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method70 = request69.method();
java.util.Map<java.lang.String, java.lang.String> strMap71 = request69.headers();
request69.followRedirects = false;
boolean boolean74 = request69.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request76 = request69.timeout((int) ' ');
java.lang.String str78 = request76.cookie("hi!");
java.lang.String str80 = request76.header("null=null");
request76.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request83 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method84 = request83.method();
java.util.Map<java.lang.String, java.lang.String> strMap85 = request83.headers();
request83.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser88 = request83.parser;
request76.parser = parser88;
org.jsoup.helper.HttpConnection.Request request90 = request63.parser(parser88);
org.jsoup.helper.HttpConnection.Request request91 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method92 = request91.method();
org.jsoup.Connection.Request request93 = request90.method(method92);
org.jsoup.Connection.Request request94 = request51.method(method92);
org.jsoup.Connection.Request request95 = request37.method(method92);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection96 = request37.data();
request0.data = keyValCollection96;
java.io.OutputStream outputStream98 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response.writePost(keyValCollection96, outputStream98);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response26);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean39 + "' != '" + false + "'", boolean39 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + false + "'", boolean43 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str50);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + false + "'", boolean56 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request62);
org.junit.Assert.assertTrue("'" + method64 + "' != '" + org.jsoup.Connection.Method.GET + "'", method64.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean65 + "' != '" + false + "'", boolean65 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request68);
org.junit.Assert.assertTrue("'" + method70 + "' != '" + org.jsoup.Connection.Method.GET + "'", method70.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean74 + "' != '" + false + "'", boolean74 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str78);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str80);
org.junit.Assert.assertTrue("'" + method84 + "' != '" + org.jsoup.Connection.Method.GET + "'", method84.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap85);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser88);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request90);
org.junit.Assert.assertTrue("'" + method92 + "' != '" + org.jsoup.Connection.Method.GET + "'", method92.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request93);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request94);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request95);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection96);
}
@Test
public void test0573() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0573");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection5 = httpConnection0.ignoreHttpErrors(true);
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
boolean boolean14 = request13.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal17 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal17.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal23 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal25 = keyVal23.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal26 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal26.key = "hi!";
java.lang.String str29 = keyVal26.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal31 = keyVal26.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal34 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal35.key = "hi!";
java.lang.String str38 = keyVal35.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str40 = keyVal39.toString();
keyVal39.value = "";
keyVal39.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal45.key = "hi!";
java.lang.String str48 = keyVal45.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal50 = keyVal45.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal51 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str52 = keyVal51.key();
org.jsoup.Connection.KeyVal[] keyValArray53 = new org.jsoup.Connection.KeyVal[] { keyVal17, keyVal20, keyVal25, keyVal26, keyVal34, keyVal35, keyVal39, keyVal45, keyVal51 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList54 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean55 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54, keyValArray53);
request13.data = keyValList54;
org.jsoup.Connection connection57 = httpConnection0.data((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54);
org.jsoup.helper.HttpConnection.Request request58 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method59 = request58.method();
java.util.Map<java.lang.String, java.lang.String> strMap60 = request58.headers();
request58.followRedirects = false;
java.lang.String str64 = request58.cookie("");
boolean boolean65 = request58.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request66 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method67 = request66.method();
java.util.Map<java.lang.String, java.lang.String> strMap68 = request66.headers();
request66.followRedirects = false;
boolean boolean71 = request66.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection72 = request66.data();
request58.data = keyValCollection72;
org.jsoup.Connection connection74 = httpConnection0.data(keyValCollection72);
org.jsoup.Connection connection76 = httpConnection0.ignoreHttpErrors(true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str29 + "' != '" + "hi!" + "'", str29.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str38 + "' != '" + "hi!" + "'", str38.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str40 + "' != '" + "null=null" + "'", str40.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str48 + "' != '" + "hi!" + "'", str48.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean55 + "' != '" + true + "'", boolean55 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
org.junit.Assert.assertTrue("'" + method59 + "' != '" + org.jsoup.Connection.Method.GET + "'", method59.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean65 + "' != '" + false + "'", boolean65 == false);
org.junit.Assert.assertTrue("'" + method67 + "' != '" + org.jsoup.Connection.Method.GET + "'", method67.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap68);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean71 + "' != '" + false + "'", boolean71 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection76);
}
@Test
public void test0574() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0574");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!";
java.net.URL uRL5 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response6 = response1.url(uRL5);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
}
@Test
public void test0575() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0575");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection2 = request0.data;
java.io.OutputStream outputStream3 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response.writePost(keyValCollection2, outputStream3);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection2);
}
@Test
public void test0576() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0576");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.lang.String str2 = response1.statusMessage();
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean8 = request3.ignoreHttpErrors;
org.jsoup.Connection.Method method9 = request3.method();
int int10 = request3.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.followRedirects;
org.jsoup.Connection.Request request15 = request11.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap16 = request11.headers();
boolean boolean17 = request11.ignoreContentType;
boolean boolean18 = request11.followRedirects();
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
org.jsoup.Connection.Request request21 = request11.method(method20);
org.jsoup.Connection.Request request22 = request3.method(method20);
org.jsoup.Connection.Response response23 = response1.method(method20);
org.jsoup.Connection.Response response26 = response1.header("null=null", "null=null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 1048576 + "'", int10 == 1048576);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + true + "'", boolean13 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + true + "'", boolean18 == true);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response26);
}
@Test
public void test0577() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0577");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry5 = request0.scanHeaders("hi!");
java.util.Map<java.lang.String, java.lang.String> strMap6 = request0.headers();
java.net.URL uRL7 = request0.url();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request8.headers();
request8.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser13 = request8.parser;
org.jsoup.Connection.Request request15 = request8.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap16 = request8.headers();
java.util.Map<java.lang.String, java.lang.String> strMap17 = request8.cookies();
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
boolean boolean20 = request18.followRedirects;
org.jsoup.Connection.Request request22 = request18.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap23 = request18.cookies();
boolean boolean25 = request18.hasCookie("null=null");
org.jsoup.parser.Parser parser26 = request18.parser();
request8.parser = parser26;
request0.parser = parser26;
org.jsoup.Connection.Request request30 = request0.removeHeader("null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + true + "'", boolean20 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
}
@Test
public void test0578() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0578");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
org.jsoup.helper.HttpConnection.Request request4 = request0.timeout(1048576);
java.lang.String str6 = request0.getHeaderCaseInsensitive("hi!=null");
boolean boolean7 = request0.ignoreContentType();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
}
@Test
public void test0579() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0579");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str6 = response1.contentType;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry8 = response1.scanHeaders("hi!=");
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document9 = response1.parse();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before parsing response");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry8);
}
@Test
public void test0580() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0580");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
boolean boolean9 = request7.followRedirects();
boolean boolean11 = request7.hasCookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection12 = request7.data();
org.jsoup.Connection.Request request14 = request7.maxBodySize((int) '#');
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
}
@Test
public void test0581() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0581");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
org.jsoup.Connection.Response response9 = response1.removeCookie("");
java.net.HttpURLConnection httpURLConnection10 = null;
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request12 = null;
org.jsoup.Connection connection13 = httpConnection11.request(request12);
org.jsoup.helper.HttpConnection httpConnection14 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response15 = httpConnection14.response();
org.jsoup.Connection.Request request16 = httpConnection14.request();
org.jsoup.Connection connection17 = httpConnection11.request(request16);
org.jsoup.Connection connection19 = httpConnection11.ignoreContentType(true);
org.jsoup.Connection connection22 = httpConnection11.data("null=hi!", "null=hi!");
org.jsoup.Connection connection24 = httpConnection11.userAgent("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection25 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response26 = httpConnection25.response();
org.jsoup.Connection connection28 = httpConnection25.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response30 = httpConnection29.response();
httpConnection25.res = response30;
org.jsoup.Connection connection33 = httpConnection25.userAgent("null=null");
org.jsoup.Connection.Request request34 = httpConnection25.request();
org.jsoup.helper.HttpConnection httpConnection35 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response36 = httpConnection35.response();
org.jsoup.Connection.Request request37 = httpConnection35.request();
org.jsoup.parser.Parser parser38 = null;
org.jsoup.Connection connection39 = httpConnection35.parser(parser38);
org.jsoup.Connection.Response response40 = httpConnection35.res;
org.jsoup.helper.HttpConnection httpConnection41 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response42 = httpConnection41.response();
org.jsoup.Connection.Request request43 = httpConnection41.request();
org.jsoup.parser.Parser parser44 = null;
org.jsoup.Connection connection45 = httpConnection41.parser(parser44);
org.jsoup.Connection.Response response46 = httpConnection41.res;
org.jsoup.Connection connection47 = httpConnection35.response(response46);
org.jsoup.Connection connection48 = httpConnection25.response(response46);
org.jsoup.helper.HttpConnection httpConnection49 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response50 = httpConnection49.response();
httpConnection25.res = response50;
httpConnection11.res = response50;
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection10, response50);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response50);
}
@Test
public void test0582() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0582");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.headers();
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str5 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = keyVal4.value("hi!");
java.lang.String str8 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal4.value("hi!");
java.lang.String str11 = keyVal4.key();
org.jsoup.helper.HttpConnection.Request request12 = request0.data((org.jsoup.Connection.KeyVal) keyVal4);
java.net.URL uRL13 = request12.url();
java.lang.String str15 = request12.cookie("null=null=null=hi!=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
}
@Test
public void test0583() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0583");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
boolean boolean9 = request0.hasHeader("null=hi!");
org.jsoup.Connection.Request request11 = request0.removeCookie("null=null");
org.jsoup.Connection.Request request13 = request0.ignoreContentType(false);
request0.timeoutMilliseconds = (short) 0;
org.jsoup.helper.HttpConnection.Response response16 = null;
org.jsoup.helper.HttpConnection.Response response17 = new org.jsoup.helper.HttpConnection.Response(response16);
int int18 = response17.statusCode();
int int19 = response17.numRedirects;
java.lang.String str20 = response17.charset;
java.lang.String str21 = response17.contentType();
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response22 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request0, response17);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 0 + "'", int19 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
}
@Test
public void test0584() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0584");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = request0.scanHeaders("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.headers();
org.jsoup.helper.HttpConnection.Response response11 = null;
org.jsoup.helper.HttpConnection.Response response12 = new org.jsoup.helper.HttpConnection.Response(response11);
int int13 = response12.statusCode();
int int14 = response12.numRedirects;
response12.charset = "";
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request22 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method23 = request22.method();
boolean boolean24 = request22.ignoreHttpErrors();
org.jsoup.Connection.Request request27 = request22.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request28 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method29 = request28.method();
java.util.Map<java.lang.String, java.lang.String> strMap30 = request28.headers();
request28.followRedirects = false;
boolean boolean33 = request28.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request35 = request28.timeout((int) ' ');
java.lang.String str37 = request35.cookie("hi!");
java.lang.String str39 = request35.header("null=null");
request35.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request42 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method43 = request42.method();
java.util.Map<java.lang.String, java.lang.String> strMap44 = request42.headers();
request42.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser47 = request42.parser;
request35.parser = parser47;
org.jsoup.helper.HttpConnection.Request request49 = request22.parser(parser47);
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
org.jsoup.Connection.Request request52 = request49.method(method51);
org.jsoup.Connection.Request request53 = request17.method(method51);
org.jsoup.Connection.Response response54 = response12.method(method51);
org.jsoup.Connection.Request request55 = response12.req;
response12.statusCode = (byte) 10;
response12.charset = "null=";
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response60 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request0, response12);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 0 + "'", int13 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str39);
org.junit.Assert.assertTrue("'" + method43 + "' != '" + org.jsoup.Connection.Method.GET + "'", method43.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request49);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request55);
}
@Test
public void test0585() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0585");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request10.headers();
int int13 = request10.timeout();
org.jsoup.parser.Parser parser14 = request10.parser();
org.jsoup.helper.HttpConnection.Request request15 = request7.parser(parser14);
java.lang.String str17 = request15.header("");
org.jsoup.Connection.Request request19 = request15.removeCookie("null=hi!");
request15.maxBodySizeBytes = (short) 0;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 3000 + "'", int13 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
}
@Test
public void test0586() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0586");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
boolean boolean6 = request0.ignoreContentType;
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "hi!");
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Request request11 = request0.timeout((int) (short) -1);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Timeout milliseconds must be 0 (infinite) or greater");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
}
@Test
public void test0587() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0587");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request10.headers();
int int13 = request10.timeout();
org.jsoup.parser.Parser parser14 = request10.parser();
org.jsoup.helper.HttpConnection.Request request15 = request7.parser(parser14);
org.jsoup.helper.HttpConnection httpConnection16 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response17 = httpConnection16.response();
org.jsoup.Connection connection19 = httpConnection16.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection20 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection23 = httpConnection20.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
java.util.Map<java.lang.String, java.lang.String> strMap26 = request24.headers();
int int27 = request24.timeout();
org.jsoup.parser.Parser parser28 = request24.parser();
org.jsoup.Connection connection29 = httpConnection20.parser(parser28);
org.jsoup.Connection connection30 = httpConnection16.parser(parser28);
request15.parser = parser28;
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
org.jsoup.helper.HttpConnection.Request request34 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method35 = request34.method();
boolean boolean36 = request34.followRedirects;
org.jsoup.Connection.Request request38 = request34.followRedirects(true);
java.lang.String str40 = request34.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request41 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method42 = request41.method();
org.jsoup.Connection.Request request43 = request34.method(method42);
org.jsoup.Connection.Request request44 = request32.method(method42);
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str46 = keyVal45.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal48 = keyVal45.value("");
java.lang.String str49 = keyVal45.value();
org.jsoup.helper.HttpConnection.Request request50 = request32.data((org.jsoup.Connection.KeyVal) keyVal45);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry52 = request50.scanHeaders("");
org.jsoup.Connection.Method method53 = request50.method();
org.jsoup.Connection.Request request54 = request15.method(method53);
java.lang.String str56 = request15.cookie("hi!=");
boolean boolean57 = request15.ignoreHttpErrors();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 3000 + "'", int13 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int27 + "' != '" + 3000 + "'", int27 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection30);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method35 + "' != '" + org.jsoup.Connection.Method.GET + "'", method35.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + true + "'", boolean36 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str40);
org.junit.Assert.assertTrue("'" + method42 + "' != '" + org.jsoup.Connection.Method.GET + "'", method42.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str46 + "' != '" + "null=null" + "'", str46.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str49 + "' != '" + "" + "'", str49.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry52);
org.junit.Assert.assertTrue("'" + method53 + "' != '" + org.jsoup.Connection.Method.GET + "'", method53.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean57 + "' != '" + false + "'", boolean57 == false);
}
@Test
public void test0588() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0588");
java.lang.String str1 = org.jsoup.helper.HttpConnection.encodeUrl("hi!=null=hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "hi!=null=hi!=null" + "'", str1.equals("hi!=null=hi!=null"));
}
@Test
public void test0589() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0589");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
boolean boolean11 = request9.followRedirects;
org.jsoup.Connection.Request request13 = request9.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap14 = request9.headers();
boolean boolean15 = request9.ignoreContentType;
request9.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap18 = request9.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request9.cookies();
java.lang.String str21 = request9.getHeaderCaseInsensitive("null=null");
org.jsoup.parser.Parser parser22 = request9.parser;
request0.parser = parser22;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + true + "'", boolean11 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser22);
}
@Test
public void test0590() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0590");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str5 = response1.statusMessage;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
}
@Test
public void test0591() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0591");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
org.jsoup.helper.HttpConnection.KeyVal keyVal8 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "");
org.jsoup.helper.HttpConnection.Request request9 = request0.data((org.jsoup.Connection.KeyVal) keyVal8);
org.jsoup.helper.HttpConnection httpConnection10 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response11 = httpConnection10.response();
org.jsoup.Connection connection13 = httpConnection10.maxBodySize((int) (short) 0);
org.jsoup.helper.HttpConnection httpConnection14 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response15 = httpConnection14.response();
httpConnection10.res = response15;
org.jsoup.Connection connection19 = httpConnection10.header("hi!", "");
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
boolean boolean22 = request20.followRedirects;
org.jsoup.Connection.Request request24 = request20.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap25 = request20.headers();
boolean boolean26 = request20.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request27 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method28 = request27.method();
java.util.Map<java.lang.String, java.lang.String> strMap29 = request27.headers();
request27.followRedirects = false;
boolean boolean32 = request27.ignoreHttpErrors;
org.jsoup.Connection.Method method33 = request27.method();
org.jsoup.helper.HttpConnection.Request request34 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method35 = request34.method();
boolean boolean36 = request34.followRedirects;
org.jsoup.Connection.Request request38 = request34.followRedirects(true);
java.lang.String str40 = request34.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request41 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method42 = request41.method();
org.jsoup.Connection.Request request43 = request34.method(method42);
org.jsoup.Connection.Request request44 = request27.method(method42);
org.jsoup.Connection.Request request45 = request20.method(method42);
org.jsoup.Connection.Request request47 = request20.removeHeader("hi!=null");
httpConnection10.req = request20;
org.jsoup.parser.Parser parser49 = request20.parser;
request9.parser = parser49;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + true + "'", boolean22 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + false + "'", boolean26 == false);
org.junit.Assert.assertTrue("'" + method28 + "' != '" + org.jsoup.Connection.Method.GET + "'", method28.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method35 + "' != '" + org.jsoup.Connection.Method.GET + "'", method35.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + true + "'", boolean36 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str40);
org.junit.Assert.assertTrue("'" + method42 + "' != '" + org.jsoup.Connection.Method.GET + "'", method42.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser49);
}
@Test
public void test0592() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0592");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str6 = response1.getHeaderCaseInsensitive("null=null");
java.net.URL uRL7 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response8 = response1.url(uRL7);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
}
@Test
public void test0593() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0593");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
java.util.Map<java.lang.String, java.lang.String> strMap7 = response1.headers();
java.lang.String str8 = response1.statusMessage;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
}
@Test
public void test0594() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0594");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
org.jsoup.Connection.Request request8 = request0.followRedirects(false);
java.lang.String str10 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
java.util.Map<java.lang.String, java.lang.String> strMap13 = request11.headers();
request11.followRedirects = false;
boolean boolean16 = request11.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request18 = request11.timeout((int) ' ');
java.lang.String str20 = request18.cookie("hi!");
java.lang.String str22 = request18.header("null=null");
request18.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser30 = request25.parser;
request18.parser = parser30;
request0.parser = parser30;
request0.ignoreContentType = false;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser30);
}
@Test
public void test0595() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0595");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request10.headers();
int int13 = request10.timeout();
org.jsoup.parser.Parser parser14 = request10.parser();
org.jsoup.helper.HttpConnection.Request request15 = request7.parser(parser14);
boolean boolean16 = request7.ignoreHttpErrors;
org.jsoup.Connection.Request request18 = request7.ignoreHttpErrors(false);
request7.ignoreContentType = true;
int int21 = request7.maxBodySizeBytes;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 3000 + "'", int13 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 1048576 + "'", int21 == 1048576);
}
@Test
public void test0596() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0596");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
org.jsoup.Connection.Request request9 = request0.method(method8);
java.net.URL uRL10 = request0.url();
java.lang.String str12 = request0.cookie("null=null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal15 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request16 = request0.data((org.jsoup.Connection.KeyVal) keyVal15);
int int17 = request0.maxBodySizeBytes;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 1048576 + "'", int17 == 1048576);
}
@Test
public void test0597() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0597");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = request0.scanHeaders("hi!");
int int10 = request0.timeoutMilliseconds;
org.jsoup.Connection.Request request13 = request0.header("null=null=null=hi!=hi!", "null=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 3000 + "'", int10 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
}
@Test
public void test0598() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0598");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal0.value("hi!");
java.lang.String str7 = keyVal6.key;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
}
@Test
public void test0599() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0599");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
org.jsoup.Connection.Method method2 = response1.method();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry4 = response1.scanHeaders("null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap5 = response1.cookies();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
}
@Test
public void test0600() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0600");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request4 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
request5.followRedirects = false;
boolean boolean10 = request5.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request12 = request5.timeout((int) ' ');
java.lang.String str14 = request12.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request12.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
boolean boolean23 = request17.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
java.util.Map<java.lang.String, java.lang.String> strMap26 = request24.headers();
request24.followRedirects = false;
boolean boolean29 = request24.ignoreHttpErrors;
org.jsoup.Connection.Method method30 = request24.method();
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
boolean boolean33 = request31.followRedirects;
org.jsoup.Connection.Request request35 = request31.followRedirects(true);
java.lang.String str37 = request31.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request38 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method39 = request38.method();
org.jsoup.Connection.Request request40 = request31.method(method39);
org.jsoup.Connection.Request request41 = request24.method(method39);
org.jsoup.Connection.Request request42 = request17.method(method39);
org.jsoup.Connection connection43 = httpConnection0.method(method39);
org.jsoup.Connection connection45 = httpConnection0.ignoreContentType(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + false + "'", boolean29 == false);
org.junit.Assert.assertTrue("'" + method30 + "' != '" + org.jsoup.Connection.Method.GET + "'", method30.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + true + "'", boolean33 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
org.junit.Assert.assertTrue("'" + method39 + "' != '" + org.jsoup.Connection.Method.GET + "'", method39.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection45);
}
@Test
public void test0601() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0601");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.lang.String str14 = request8.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
org.jsoup.Connection.Request request17 = request8.method(method16);
org.jsoup.Connection.Request request18 = request6.method(method16);
boolean boolean20 = request6.hasHeader("hi!");
org.jsoup.Connection.Request request22 = request6.removeCookie("");
httpConnection0.req = request22;
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request25 = null;
org.jsoup.Connection connection26 = httpConnection24.request(request25);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection connection29 = httpConnection24.response(response28);
httpConnection0.res = response28;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
boolean boolean33 = request31.ignoreHttpErrors();
org.jsoup.Connection.Request request36 = request31.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
request37.followRedirects = false;
boolean boolean42 = request37.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request44 = request37.timeout((int) ' ');
java.lang.String str46 = request44.cookie("hi!");
java.lang.String str48 = request44.header("null=null");
request44.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
java.util.Map<java.lang.String, java.lang.String> strMap53 = request51.headers();
request51.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser56 = request51.parser;
request44.parser = parser56;
org.jsoup.helper.HttpConnection.Request request58 = request31.parser(parser56);
org.jsoup.helper.HttpConnection.Request request59 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method60 = request59.method();
org.jsoup.Connection.Request request61 = request58.method(method60);
org.jsoup.Connection connection62 = httpConnection0.method(method60);
org.jsoup.Connection connection64 = httpConnection0.ignoreHttpErrors(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + false + "'", boolean42 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection64);
}
@Test
public void test0602() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0602");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.net.URL uRL7 = response1.url();
int int8 = response1.statusCode();
response1.contentType = "hi!=null";
boolean boolean12 = response1.hasCookie("null=null=null=hi!");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response15 = response1.header("", "");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
}
@Test
public void test0603() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0603");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.toString();
keyVal0.value = "";
keyVal0.value = "null=hi!";
keyVal0.key = "null=null";
java.lang.String str8 = keyVal0.toString();
java.lang.String str9 = keyVal0.value();
org.jsoup.helper.HttpConnection.KeyVal keyVal11 = keyVal0.key("null=null");
keyVal11.key = "null=";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "null=null" + "'", str1.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str8 + "' != '" + "null=null=null=hi!" + "'", str8.equals("null=null=null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str9 + "' != '" + "null=hi!" + "'", str9.equals("null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal11);
}
@Test
public void test0604() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0604");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
org.jsoup.Connection.Request request8 = request0.followRedirects(false);
java.lang.String str10 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.followRedirects;
org.jsoup.Connection.Request request15 = request11.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap16 = request11.headers();
boolean boolean17 = request11.ignoreContentType;
request11.maxBodySizeBytes = (short) 100;
org.jsoup.parser.Parser parser20 = request11.parser;
org.jsoup.helper.HttpConnection.Request request21 = request0.parser(parser20);
java.lang.String str23 = request0.header("hi!=null");
boolean boolean24 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
boolean boolean27 = request25.followRedirects;
org.jsoup.Connection.Request request29 = request25.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap30 = request25.cookies();
boolean boolean32 = request25.hasCookie("");
org.jsoup.helper.HttpConnection.KeyVal keyVal33 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str34 = keyVal33.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal36 = keyVal33.value("hi!");
java.lang.String str37 = keyVal33.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = keyVal33.value("hi!");
java.lang.String str40 = keyVal33.key();
org.jsoup.helper.HttpConnection.Request request41 = request25.data((org.jsoup.Connection.KeyVal) keyVal33);
org.jsoup.helper.HttpConnection.Request request42 = request0.data((org.jsoup.Connection.KeyVal) keyVal33);
org.jsoup.Connection.Request request44 = request0.ignoreHttpErrors(false);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + true + "'", boolean13 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + true + "'", boolean27 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
}
@Test
public void test0605() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0605");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
org.jsoup.parser.Parser parser5 = request0.parser;
request0.ignoreHttpErrors = true;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser5);
}
@Test
public void test0606() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0606");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request4 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
request5.followRedirects = false;
boolean boolean10 = request5.ignoreHttpErrors;
org.jsoup.Connection.Method method11 = request5.method();
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
boolean boolean14 = request12.followRedirects;
org.jsoup.Connection.Request request16 = request12.followRedirects(true);
java.lang.String str18 = request12.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
org.jsoup.Connection.Request request21 = request12.method(method20);
org.jsoup.Connection.Request request22 = request5.method(method20);
org.jsoup.Connection connection23 = httpConnection0.method(method20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + true + "'", boolean14 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str18);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
}
@Test
public void test0607() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0607");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry11 = request0.scanHeaders("hi!=null=hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry11);
}
@Test
public void test0608() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0608");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
java.lang.String str3 = keyVal2.value();
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal2.key("null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "null=null" + "'", str3.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
}
@Test
public void test0609() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0609");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection.Response response3 = httpConnection0.response();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response3);
}
@Test
public void test0610() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0610");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal3.key;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
}
@Test
public void test0611() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0611");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
int int12 = request7.maxBodySize();
java.lang.String str14 = request7.header("hi!");
org.jsoup.parser.Parser parser15 = request7.parser;
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
java.util.Map<java.lang.String, java.lang.String> strMap18 = request16.headers();
request16.followRedirects = false;
boolean boolean21 = request16.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request23 = request16.timeout((int) ' ');
boolean boolean24 = request23.followRedirects();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry26 = request23.scanHeaders("");
request23.ignoreContentType = false;
org.jsoup.Connection.Method method29 = request23.method();
org.jsoup.Connection.Request request30 = request7.method(method29);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser15);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry26);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
}
@Test
public void test0612() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0612");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
boolean boolean6 = request0.ignoreContentType;
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "hi!");
java.lang.String str11 = request0.getHeaderCaseInsensitive("");
java.lang.String str13 = request0.cookie("");
request0.ignoreContentType = false;
java.util.Map<java.lang.String, java.lang.String> strMap16 = request0.cookies();
request0.ignoreContentType = true;
org.jsoup.Connection.Request request20 = request0.removeHeader("null=");
org.jsoup.Connection.Request request22 = request0.ignoreContentType(true);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
}
@Test
public void test0613() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0613");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.ignoreHttpErrors();
org.jsoup.Connection.Request request16 = request11.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
boolean boolean22 = request17.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request24 = request17.timeout((int) ' ');
java.lang.String str26 = request24.cookie("hi!");
java.lang.String str28 = request24.header("null=null");
request24.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser36 = request31.parser;
request24.parser = parser36;
org.jsoup.helper.HttpConnection.Request request38 = request11.parser(parser36);
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request38.method(method40);
org.jsoup.Connection.Request request42 = request6.method(method40);
org.jsoup.Connection.Response response43 = response1.method(method40);
org.jsoup.helper.HttpConnection.Response response44 = new org.jsoup.helper.HttpConnection.Response(response1);
java.lang.String str45 = response1.charset();
response1.statusCode = 1048576;
int int48 = response1.numRedirects;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str28);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str45 + "' != '" + "" + "'", str45.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int48 + "' != '" + 0 + "'", int48 == 0);
}
@Test
public void test0614() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0614");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
int int3 = request0.timeout();
boolean boolean4 = request0.ignoreHttpErrors();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
request0.ignoreContentType = true;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3000 + "'", int3 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
}
@Test
public void test0615() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0615");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
boolean boolean11 = request7.hasCookie("null=hi!");
request7.maxBodySizeBytes = (byte) 1;
org.jsoup.Connection.Method method14 = request7.method();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
}
@Test
public void test0616() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0616");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
org.jsoup.Connection.Method method2 = response1.method();
org.jsoup.Connection.Response response4 = response1.removeHeader("hi!");
java.net.URL uRL5 = response1.url();
response1.statusCode = (short) 10;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
}
@Test
public void test0617() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0617");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("null=null=null=hi!", "hi!");
keyVal2.key = "null=null";
}
@Test
public void test0618() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0618");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
boolean boolean4 = request0.hasCookie("null=hi!");
request0.timeoutMilliseconds = (byte) -1;
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
org.jsoup.helper.HttpConnection.Request request14 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap15 = request14.headers();
org.jsoup.Connection connection16 = httpConnection7.request((org.jsoup.Connection.Request) request14);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry18 = request14.scanHeaders("null=null");
org.jsoup.Connection.Request request20 = request14.ignoreContentType(false);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection21 = request14.data;
org.jsoup.helper.HttpConnection.Request request22 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method23 = request22.method();
org.jsoup.Connection.Request request25 = request22.ignoreContentType(false);
org.jsoup.Connection.Request request27 = request22.removeCookie("");
int int28 = request22.maxBodySize();
org.jsoup.Connection.Request request30 = request22.followRedirects(false);
java.lang.String str32 = request22.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
java.util.Map<java.lang.String, java.lang.String> strMap35 = request33.headers();
request33.followRedirects = false;
boolean boolean38 = request33.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request40 = request33.timeout((int) ' ');
java.lang.String str42 = request40.cookie("hi!");
java.lang.String str44 = request40.header("null=null");
request40.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request47 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method48 = request47.method();
java.util.Map<java.lang.String, java.lang.String> strMap49 = request47.headers();
request47.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser52 = request47.parser;
request40.parser = parser52;
request22.parser = parser52;
org.jsoup.helper.HttpConnection.Request request55 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method56 = request55.method();
boolean boolean57 = request55.ignoreHttpErrors();
org.jsoup.Connection.Request request60 = request55.cookie("hi!", "");
boolean boolean61 = request55.ignoreContentType;
org.jsoup.parser.Parser parser62 = request55.parser();
request22.parser = parser62;
request14.parser = parser62;
org.jsoup.helper.HttpConnection.Request request65 = request0.parser(parser62);
org.jsoup.Connection.Request request68 = request65.header("hi!=null", "null=null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection21);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 1048576 + "'", int28 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str32);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + false + "'", boolean38 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str44);
org.junit.Assert.assertTrue("'" + method48 + "' != '" + org.jsoup.Connection.Method.GET + "'", method48.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser52);
org.junit.Assert.assertTrue("'" + method56 + "' != '" + org.jsoup.Connection.Method.GET + "'", method56.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean57 + "' != '" + false + "'", boolean57 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean61 + "' != '" + false + "'", boolean61 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request68);
}
@Test
public void test0619() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0619");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
org.jsoup.Connection.Method method2 = response1.method();
boolean boolean4 = response1.hasCookie("");
boolean boolean6 = response1.hasCookie("null=");
org.jsoup.Connection.Response response9 = response1.cookie("null=null=", "null=null=hi!");
org.jsoup.Connection.Response response11 = response1.removeHeader("null=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
}
@Test
public void test0620() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0620");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
org.jsoup.Connection.Response response8 = response1.header("null=null=hi!", "null=null=hi!");
java.nio.ByteBuffer byteBuffer9 = response1.byteData;
java.lang.String str10 = response1.contentType;
int int11 = response1.statusCode;
java.net.HttpURLConnection httpURLConnection12 = null;
org.jsoup.helper.HttpConnection.Response response13 = null;
org.jsoup.helper.HttpConnection.Response response14 = new org.jsoup.helper.HttpConnection.Response(response13);
int int15 = response14.statusCode();
int int16 = response14.numRedirects;
response14.charset = "";
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
org.jsoup.Connection.Request request22 = request19.ignoreContentType(false);
org.jsoup.Connection.Request request24 = request19.removeCookie("");
int int25 = request19.maxBodySize();
org.jsoup.Connection.Request request27 = request19.followRedirects(false);
response14.req = request19;
java.lang.String str30 = response14.cookie("null=null=hi!");
boolean boolean32 = response14.hasHeader("null=");
java.lang.String str34 = response14.header("hi!");
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection12, (org.jsoup.Connection.Response) response14);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(byteBuffer9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 0 + "'", int11 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 0 + "'", int16 == 0);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 1048576 + "'", int25 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str34);
}
@Test
public void test0621() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0621");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.statusMessage;
org.jsoup.Connection.Response response7 = response1.removeCookie("hi!");
java.lang.String str8 = response1.statusMessage;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
}
@Test
public void test0622() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0622");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.Connection connection8 = httpConnection0.userAgent("null=null");
org.jsoup.Connection.Request request9 = httpConnection0.request();
org.jsoup.helper.HttpConnection httpConnection10 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response11 = httpConnection10.response();
org.jsoup.Connection.Request request12 = httpConnection10.request();
org.jsoup.parser.Parser parser13 = null;
org.jsoup.Connection connection14 = httpConnection10.parser(parser13);
org.jsoup.Connection.Response response15 = httpConnection10.res;
org.jsoup.helper.HttpConnection httpConnection16 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response17 = httpConnection16.response();
org.jsoup.Connection.Request request18 = httpConnection16.request();
org.jsoup.parser.Parser parser19 = null;
org.jsoup.Connection connection20 = httpConnection16.parser(parser19);
org.jsoup.Connection.Response response21 = httpConnection16.res;
org.jsoup.Connection connection22 = httpConnection10.response(response21);
org.jsoup.Connection connection23 = httpConnection0.response(response21);
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document24 = httpConnection0.get();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
}
@Test
public void test0623() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0623");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request9 = request0.timeout((int) (byte) 0);
java.lang.String str11 = request0.header("");
java.net.URL uRL12 = request0.url();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL12);
}
@Test
public void test0624() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0624");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.Connection connection6 = httpConnection0.header("null=null=null=hi!", "");
org.jsoup.Connection connection9 = httpConnection0.cookie("null=null=hi!", "null=hi!");
org.jsoup.Connection connection11 = httpConnection0.followRedirects(true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
}
@Test
public void test0625() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0625");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.ignoreHttpErrors();
org.jsoup.Connection.Request request16 = request11.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
boolean boolean22 = request17.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request24 = request17.timeout((int) ' ');
java.lang.String str26 = request24.cookie("hi!");
java.lang.String str28 = request24.header("null=null");
request24.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser36 = request31.parser;
request24.parser = parser36;
org.jsoup.helper.HttpConnection.Request request38 = request11.parser(parser36);
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request38.method(method40);
org.jsoup.Connection.Request request42 = request6.method(method40);
org.jsoup.Connection.Response response43 = response1.method(method40);
org.jsoup.Connection.Request request44 = response1.req;
response1.statusCode = (byte) 10;
response1.charset = "null=";
boolean boolean50 = response1.hasCookie("null=null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str28);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean50 + "' != '" + false + "'", boolean50 == false);
}
@Test
public void test0626() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0626");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
org.jsoup.Connection.Response response10 = response1.cookie("null=null=hi!", "hi!=null");
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document11 = response1.parse();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before parsing response");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response10);
}
@Test
public void test0627() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0627");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.maxBodySizeBytes = (short) 100;
org.jsoup.parser.Parser parser9 = request0.parser;
boolean boolean10 = request0.ignoreContentType;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
}
@Test
public void test0628() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0628");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
java.net.URL uRL8 = request0.url();
java.lang.String str10 = request0.header("null=null=hi!");
boolean boolean11 = request0.ignoreContentType();
boolean boolean12 = request0.ignoreHttpErrors;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
}
@Test
public void test0629() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0629");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
org.jsoup.Connection.Response response10 = response1.cookie("null=null=hi!", "hi!=null");
java.util.Map<java.lang.String, java.lang.String> strMap11 = response1.headers();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap11);
}
@Test
public void test0630() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0630");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request9 = request0.timeout((int) (byte) 0);
org.jsoup.parser.Parser parser10 = request0.parser();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser10);
}
@Test
public void test0631() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0631");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.maxBodySizeBytes = (short) 100;
org.jsoup.parser.Parser parser9 = request0.parser;
request0.followRedirects = true;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser9);
}
@Test
public void test0632() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0632");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
java.lang.String str15 = request13.cookie("hi!");
java.lang.String str17 = request13.header("null=null");
request13.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
java.util.Map<java.lang.String, java.lang.String> strMap22 = request20.headers();
request20.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser25 = request20.parser;
request13.parser = parser25;
org.jsoup.helper.HttpConnection.Request request27 = request0.parser(parser25);
boolean boolean28 = request0.ignoreHttpErrors();
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response30 = httpConnection29.response();
org.jsoup.Connection connection32 = httpConnection29.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection33 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection36 = httpConnection33.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
int int40 = request37.timeout();
org.jsoup.parser.Parser parser41 = request37.parser();
org.jsoup.Connection connection42 = httpConnection33.parser(parser41);
org.jsoup.Connection connection43 = httpConnection29.parser(parser41);
org.jsoup.helper.HttpConnection.Request request44 = request0.parser(parser41);
int int45 = request44.timeout();
int int46 = request44.timeout();
org.jsoup.parser.Parser parser47 = request44.parser;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 3000 + "'", int40 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 3000 + "'", int45 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 3000 + "'", int46 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser47);
}
@Test
public void test0633() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0633");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request0.followRedirects();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection9 = request0.data();
org.jsoup.Connection.Request request12 = request0.cookie("hi!=", "hi!=null=hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
}
@Test
public void test0634() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0634");
org.jsoup.helper.HttpConnection.Response.MAX_REDIRECTS = (byte) -1;
}
@Test
public void test0635() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0635");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str5 = response1.statusMessage();
response1.numRedirects = (-1);
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.ignoreHttpErrors();
org.jsoup.Connection.Request request13 = request8.cookie("hi!", "");
boolean boolean14 = request8.ignoreContentType;
org.jsoup.parser.Parser parser15 = request8.parser();
response1.req = request8;
java.net.URL uRL17 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request18 = request8.url(uRL17);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser15);
}
@Test
public void test0636() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0636");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "");
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = keyVal2.key("null=null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal2.key("null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
}
@Test
public void test0637() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0637");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
boolean boolean6 = request0.hasHeader("hi!=null");
org.jsoup.Connection.Request request8 = request0.ignoreContentType(false);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
}
@Test
public void test0638() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0638");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.Connection connection8 = httpConnection0.userAgent("null=null");
org.jsoup.Connection.Response response9 = httpConnection0.response();
org.jsoup.Connection.Request request10 = null;
org.jsoup.Connection connection11 = httpConnection0.request(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
}
@Test
public void test0639() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0639");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
java.lang.String str8 = request0.cookie("null=null=null=hi!");
org.jsoup.Connection.Request request10 = request0.removeCookie("null=hi!");
java.lang.String str12 = request0.getHeaderCaseInsensitive("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal15 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal15.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal19 = keyVal15.value("null=null");
java.lang.String str20 = keyVal19.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal22 = keyVal19.key("null=hi!");
org.jsoup.helper.HttpConnection.Request request23 = request0.data((org.jsoup.Connection.KeyVal) keyVal22);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str20 + "' != '" + "" + "'", str20.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
}
@Test
public void test0640() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0640");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
java.net.URL uRL7 = request0.url();
boolean boolean8 = request0.followRedirects;
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str10 = keyVal9.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal12 = keyVal9.value("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal14 = keyVal9.key("hi!");
java.lang.String str15 = keyVal9.value;
org.jsoup.helper.HttpConnection.Request request16 = request0.data((org.jsoup.Connection.KeyVal) keyVal9);
org.jsoup.Connection.Request request19 = request16.header("null=hi!", "null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str15 + "' != '" + "hi!" + "'", str15.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
}
@Test
public void test0641() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0641");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection7 = httpConnection4.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request8.headers();
int int11 = request8.timeout();
org.jsoup.parser.Parser parser12 = request8.parser();
org.jsoup.Connection connection13 = httpConnection4.parser(parser12);
org.jsoup.Connection connection14 = httpConnection0.parser(parser12);
org.jsoup.Connection connection16 = httpConnection0.userAgent("hi!=null");
org.jsoup.Connection.Request request17 = httpConnection0.req;
org.jsoup.Connection.Response response18 = httpConnection0.response();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3000 + "'", int11 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response18);
}
@Test
public void test0642() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0642");
java.lang.String str1 = org.jsoup.helper.HttpConnection.encodeUrl("null=null=null=hi!=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "null=null=null=hi!=hi!" + "'", str1.equals("null=null=null=hi!=hi!"));
}
@Test
public void test0643() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0643");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal0.key = "hi!";
java.lang.String str3 = keyVal0.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal0.key("hi!");
java.lang.String str6 = keyVal0.value();
keyVal0.key = "null=";
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal0.value("null=null=hi!");
java.lang.String str11 = keyVal0.value;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "hi!" + "'", str3.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str11 + "' != '" + "null=null=hi!" + "'", str11.equals("null=null=hi!"));
}
@Test
public void test0644() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0644");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
org.jsoup.Connection.Request request11 = request6.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean17 = request12.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request19 = request12.timeout((int) ' ');
java.lang.String str21 = request19.cookie("hi!");
java.lang.String str23 = request19.header("null=null");
request19.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser31 = request26.parser;
request19.parser = parser31;
org.jsoup.helper.HttpConnection.Request request33 = request6.parser(parser31);
org.jsoup.Connection connection34 = httpConnection0.request((org.jsoup.Connection.Request) request33);
org.jsoup.Connection connection36 = httpConnection0.userAgent("");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
request37.followRedirects = false;
java.lang.String str43 = request37.cookie("");
boolean boolean44 = request37.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request45 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method46 = request45.method();
java.util.Map<java.lang.String, java.lang.String> strMap47 = request45.headers();
request45.followRedirects = false;
boolean boolean50 = request45.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection51 = request45.data();
request37.data = keyValCollection51;
org.jsoup.Connection connection53 = httpConnection0.data(keyValCollection51);
org.jsoup.Connection connection56 = httpConnection0.header("hi!", "null=");
org.jsoup.Connection connection59 = httpConnection0.header("hi!=", "null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean44 + "' != '" + false + "'", boolean44 == false);
org.junit.Assert.assertTrue("'" + method46 + "' != '" + org.jsoup.Connection.Method.GET + "'", method46.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean50 + "' != '" + false + "'", boolean50 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection59);
}
@Test
public void test0645() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0645");
java.lang.String str1 = org.jsoup.helper.HttpConnection.encodeUrl("null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "null=" + "'", str1.equals("null="));
}
@Test
public void test0646() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0646");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
boolean boolean9 = request7.followRedirects();
org.jsoup.Connection.Request request11 = request7.followRedirects(true);
int int12 = request7.timeoutMilliseconds;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 32 + "'", int12 == 32);
}
@Test
public void test0647() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0647");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.lang.String str14 = request8.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
org.jsoup.Connection.Request request17 = request8.method(method16);
org.jsoup.Connection.Request request18 = request6.method(method16);
boolean boolean20 = request6.hasHeader("hi!");
org.jsoup.Connection.Request request22 = request6.removeCookie("");
httpConnection0.req = request22;
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request25 = null;
org.jsoup.Connection connection26 = httpConnection24.request(request25);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection connection29 = httpConnection24.response(response28);
httpConnection0.res = response28;
org.jsoup.Connection connection32 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection34 = httpConnection0.userAgent("null=null");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response35 = httpConnection0.execute();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
}
@Test
public void test0648() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0648");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean9 = request3.hasCookie("null=null");
java.lang.String str11 = request3.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection connection12 = httpConnection0.request((org.jsoup.Connection.Request) request3);
org.jsoup.helper.HttpConnection httpConnection13 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response14 = httpConnection13.response();
httpConnection0.res = response14;
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
org.jsoup.Connection.Request request19 = request16.ignoreContentType(false);
org.jsoup.parser.Parser parser20 = null;
request16.parser = parser20;
int int22 = request16.timeoutMilliseconds;
java.util.Map<java.lang.String, java.lang.String> strMap23 = request16.headers();
org.jsoup.Connection connection24 = httpConnection0.data(strMap23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response14);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 3000 + "'", int22 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
}
@Test
public void test0649() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0649");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.lang.String str14 = request8.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
org.jsoup.Connection.Request request17 = request8.method(method16);
org.jsoup.Connection.Request request18 = request6.method(method16);
boolean boolean20 = request6.hasHeader("hi!");
org.jsoup.Connection.Request request22 = request6.removeCookie("");
httpConnection0.req = request22;
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request25 = null;
org.jsoup.Connection connection26 = httpConnection24.request(request25);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection connection29 = httpConnection24.response(response28);
httpConnection0.res = response28;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
java.util.Map<java.lang.String, java.lang.String> strMap34 = request31.cookies();
org.jsoup.Connection connection35 = httpConnection0.data(strMap34);
org.jsoup.helper.HttpConnection.Response response36 = null;
org.jsoup.helper.HttpConnection.Response response37 = new org.jsoup.helper.HttpConnection.Response(response36);
int int38 = response37.statusCode();
int int39 = response37.numRedirects;
java.lang.String str40 = response37.charset;
java.lang.String str41 = response37.statusMessage;
org.jsoup.Connection.Response response43 = response37.removeCookie("hi!");
int int44 = response37.numRedirects;
java.lang.String str46 = response37.cookie("hi!");
java.util.Map<java.lang.String, java.lang.String> strMap47 = response37.cookies();
java.lang.String str48 = response37.statusMessage;
httpConnection0.res = response37;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 0 + "'", int38 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 0 + "'", int39 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int44 + "' != '" + 0 + "'", int44 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
}
@Test
public void test0650() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0650");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
request0.timeoutMilliseconds = 307;
request0.ignoreContentType = false;
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
org.jsoup.Connection.Request request12 = request0.ignoreContentType(true);
request0.ignoreHttpErrors = false;
org.jsoup.helper.HttpConnection.KeyVal keyVal15 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal15.key = "hi!";
java.lang.String str18 = keyVal15.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = keyVal15.key("hi!");
java.lang.String str21 = keyVal20.value;
org.jsoup.helper.HttpConnection.Request request22 = request0.data((org.jsoup.Connection.KeyVal) keyVal20);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str18 + "' != '" + "hi!" + "'", str18.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
}
@Test
public void test0651() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0651");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("null=null=null=hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = keyVal2.value("hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal4);
}
@Test
public void test0652() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0652");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
response1.charset = "null=null";
java.lang.String str9 = response1.charset();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str9 + "' != '" + "null=null" + "'", str9.equals("null=null"));
}
@Test
public void test0653() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0653");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.lang.String str2 = response1.statusMessage();
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean8 = request3.ignoreHttpErrors;
org.jsoup.Connection.Method method9 = request3.method();
int int10 = request3.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.followRedirects;
org.jsoup.Connection.Request request15 = request11.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap16 = request11.headers();
boolean boolean17 = request11.ignoreContentType;
boolean boolean18 = request11.followRedirects();
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
org.jsoup.Connection.Request request21 = request11.method(method20);
org.jsoup.Connection.Request request22 = request3.method(method20);
org.jsoup.Connection.Response response23 = response1.method(method20);
java.nio.ByteBuffer byteBuffer24 = null;
response1.byteData = byteBuffer24;
org.jsoup.Connection.Response response27 = response1.removeHeader("null=");
java.lang.String str28 = response1.statusMessage();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 1048576 + "'", int10 == 1048576);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + true + "'", boolean13 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + true + "'", boolean18 == true);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str28);
}
@Test
public void test0654() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0654");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection connection4 = httpConnection0.ignoreContentType(true);
org.jsoup.Connection.Request request5 = httpConnection0.request();
org.jsoup.Connection connection7 = httpConnection0.referrer("null=hi!");
org.jsoup.Connection.Response response8 = httpConnection0.response();
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection11 = httpConnection0.data("", "null=null");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Data key must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
}
@Test
public void test0655() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0655");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request4 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
request5.followRedirects = false;
boolean boolean10 = request5.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request12 = request5.timeout((int) ' ');
java.lang.String str14 = request12.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request12.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
request17.timeoutMilliseconds = 307;
org.jsoup.parser.Parser parser25 = request17.parser();
org.jsoup.Connection connection26 = httpConnection0.parser(parser25);
org.jsoup.Connection connection29 = httpConnection0.data("null=null", "null=null");
org.jsoup.Connection.Request request30 = httpConnection0.request();
org.jsoup.Connection connection33 = httpConnection0.cookie("null=null", "null=");
org.jsoup.helper.HttpConnection httpConnection34 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response35 = httpConnection34.response();
org.jsoup.Connection.Request request36 = httpConnection34.request();
org.jsoup.Connection connection38 = httpConnection34.ignoreContentType(true);
org.jsoup.Connection.Request request39 = httpConnection34.request();
org.jsoup.Connection connection41 = httpConnection34.referrer("null=hi!");
org.jsoup.helper.HttpConnection httpConnection42 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request43 = null;
org.jsoup.Connection connection44 = httpConnection42.request(request43);
org.jsoup.helper.HttpConnection httpConnection45 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response46 = httpConnection45.response();
org.jsoup.Connection.Request request47 = httpConnection45.request();
org.jsoup.Connection connection48 = httpConnection42.request(request47);
org.jsoup.helper.HttpConnection httpConnection49 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection51 = httpConnection49.followRedirects(false);
org.jsoup.Connection connection53 = httpConnection49.referrer("");
org.jsoup.Connection.Response response54 = httpConnection49.response();
org.jsoup.Connection connection55 = httpConnection42.response(response54);
org.jsoup.Connection connection57 = httpConnection42.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request58 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method59 = request58.method();
boolean boolean60 = request58.ignoreHttpErrors();
org.jsoup.Connection.Request request63 = request58.cookie("hi!", "");
java.lang.String str65 = request58.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request66 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method67 = request66.method();
boolean boolean68 = request66.followRedirects;
org.jsoup.Connection.Request request70 = request66.followRedirects(true);
java.lang.String str72 = request66.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request73 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method74 = request73.method();
org.jsoup.Connection.Request request75 = request66.method(method74);
org.jsoup.Connection.Request request76 = request58.method(method74);
org.jsoup.Connection connection77 = httpConnection42.method(method74);
org.jsoup.Connection connection79 = httpConnection42.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection80 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response81 = httpConnection80.response();
org.jsoup.Connection connection83 = httpConnection80.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection84 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response85 = httpConnection84.response();
httpConnection80.res = response85;
java.lang.String[] strArray89 = new java.lang.String[] { "null=null", "null=null" };
org.jsoup.Connection connection90 = httpConnection80.data(strArray89);
org.jsoup.Connection connection91 = httpConnection42.data(strArray89);
org.jsoup.Connection connection92 = httpConnection34.data(strArray89);
org.jsoup.Connection connection93 = httpConnection0.data(strArray89);
org.jsoup.Connection connection96 = httpConnection0.cookie("hi!", "");
org.jsoup.Connection.Request request97 = httpConnection0.request();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
org.junit.Assert.assertTrue("'" + method59 + "' != '" + org.jsoup.Connection.Method.GET + "'", method59.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean60 + "' != '" + false + "'", boolean60 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str65);
org.junit.Assert.assertTrue("'" + method67 + "' != '" + org.jsoup.Connection.Method.GET + "'", method67.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean68 + "' != '" + true + "'", boolean68 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request70);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str72);
org.junit.Assert.assertTrue("'" + method74 + "' != '" + org.jsoup.Connection.Method.GET + "'", method74.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection79);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response81);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection83);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response85);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray89);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection90);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection91);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection92);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection93);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection96);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request97);
}
@Test
public void test0656() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0656");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
}
@Test
public void test0657() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0657");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
java.net.URL uRL8 = request0.url();
java.lang.String str10 = request0.header("null=null=hi!");
boolean boolean12 = request0.hasHeader("null=null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
}
@Test
public void test0658() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0658");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
int int3 = request0.timeout();
boolean boolean4 = request0.ignoreHttpErrors();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = org.jsoup.helper.HttpConnection.KeyVal.create("null=null=null=hi!", "null=null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal7.key("hi!=");
keyVal7.value = "";
org.jsoup.helper.HttpConnection.Request request12 = request0.data((org.jsoup.Connection.KeyVal) keyVal7);
boolean boolean14 = request0.hasCookie("hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3000 + "'", int3 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
}
@Test
public void test0659() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0659");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
java.lang.String str6 = request0.cookie("null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
}
@Test
public void test0660() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0660");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection14 = httpConnection11.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
java.util.Map<java.lang.String, java.lang.String> strMap17 = request15.headers();
int int18 = request15.timeout();
org.jsoup.parser.Parser parser19 = request15.parser();
org.jsoup.Connection connection20 = httpConnection11.parser(parser19);
org.jsoup.Connection connection21 = httpConnection7.parser(parser19);
org.jsoup.Connection connection22 = httpConnection0.parser(parser19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 3000 + "'", int18 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
}
@Test
public void test0661() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0661");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean6 = request0.hasCookie("null=null");
java.lang.String str8 = request0.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection.Request request10 = request0.removeHeader("hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
}
@Test
public void test0662() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0662");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreHttpErrors;
org.jsoup.Connection.Request request11 = request7.header("null=", "null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
}
@Test
public void test0663() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0663");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
boolean boolean7 = request5.ignoreHttpErrors();
org.jsoup.Connection.Request request10 = request5.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
java.util.Map<java.lang.String, java.lang.String> strMap13 = request11.headers();
request11.followRedirects = false;
boolean boolean16 = request11.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request18 = request11.timeout((int) ' ');
java.lang.String str20 = request18.cookie("hi!");
java.lang.String str22 = request18.header("null=null");
request18.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser30 = request25.parser;
request18.parser = parser30;
org.jsoup.helper.HttpConnection.Request request32 = request5.parser(parser30);
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
org.jsoup.Connection.Request request35 = request32.method(method34);
org.jsoup.Connection.Request request36 = request0.method(method34);
java.net.URL uRL37 = request0.url();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request32);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL37);
}
@Test
public void test0664() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0664");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
response1.statusMessage = "hi!=";
java.lang.String str4 = response1.statusMessage;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str4 + "' != '" + "hi!=" + "'", str4.equals("hi!="));
}
@Test
public void test0665() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0665");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("null=", "null=");
java.lang.String str3 = keyVal2.value();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "null=" + "'", str3.equals("null="));
}
@Test
public void test0666() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0666");
org.jsoup.helper.HttpConnection.HTTP_TEMP_REDIR = 32;
}
@Test
public void test0667() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0667");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.req;
org.jsoup.Connection connection4 = httpConnection0.ignoreContentType(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection7 = httpConnection5.followRedirects(false);
org.jsoup.Connection connection9 = httpConnection5.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection10 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response11 = httpConnection10.response();
org.jsoup.helper.HttpConnection httpConnection12 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response13 = httpConnection12.response();
org.jsoup.Connection connection15 = httpConnection12.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection16 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response17 = httpConnection16.response();
httpConnection12.res = response17;
httpConnection10.res = response17;
org.jsoup.Connection connection20 = httpConnection5.response(response17);
org.jsoup.helper.HttpConnection.Request request21 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method22 = request21.method();
boolean boolean23 = request21.followRedirects;
org.jsoup.Connection.Request request25 = request21.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap26 = request21.cookies();
org.jsoup.Connection connection27 = httpConnection5.cookies(strMap26);
org.jsoup.helper.HttpConnection.Request request28 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method29 = request28.method();
java.util.Map<java.lang.String, java.lang.String> strMap30 = request28.headers();
request28.followRedirects = false;
boolean boolean33 = request28.ignoreHttpErrors;
org.jsoup.Connection.Method method34 = request28.method();
int int35 = request28.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request36 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method37 = request36.method();
boolean boolean38 = request36.followRedirects;
org.jsoup.Connection.Request request40 = request36.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap41 = request36.headers();
boolean boolean42 = request36.ignoreContentType;
boolean boolean43 = request36.followRedirects();
org.jsoup.helper.HttpConnection.Request request44 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method45 = request44.method();
org.jsoup.Connection.Request request46 = request36.method(method45);
org.jsoup.Connection.Request request47 = request28.method(method45);
org.jsoup.Connection connection48 = httpConnection5.method(method45);
org.jsoup.Connection connection49 = httpConnection0.method(method45);
org.jsoup.helper.HttpConnection httpConnection50 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response51 = httpConnection50.response();
org.jsoup.Connection.Request request52 = httpConnection50.request();
org.jsoup.parser.Parser parser53 = null;
org.jsoup.Connection connection54 = httpConnection50.parser(parser53);
org.jsoup.Connection.Response response55 = httpConnection50.res;
org.jsoup.helper.HttpConnection.Request request56 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method57 = request56.method();
org.jsoup.Connection.Request request59 = request56.ignoreContentType(false);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry61 = request56.scanHeaders("hi!");
java.util.Map<java.lang.String, java.lang.String> strMap62 = request56.headers();
org.jsoup.Connection connection63 = httpConnection50.data(strMap62);
org.jsoup.helper.HttpConnection.Request request64 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method65 = request64.method();
org.jsoup.Connection.Request request67 = request64.ignoreContentType(false);
org.jsoup.Connection.Request request69 = request64.removeCookie("");
int int70 = request64.maxBodySize();
org.jsoup.Connection.Request request72 = request64.followRedirects(false);
java.lang.String str74 = request64.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request75 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method76 = request75.method();
java.util.Map<java.lang.String, java.lang.String> strMap77 = request75.headers();
request75.followRedirects = false;
boolean boolean80 = request75.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request82 = request75.timeout((int) ' ');
java.lang.String str84 = request82.cookie("hi!");
java.lang.String str86 = request82.header("null=null");
request82.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request89 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method90 = request89.method();
java.util.Map<java.lang.String, java.lang.String> strMap91 = request89.headers();
request89.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser94 = request89.parser;
request82.parser = parser94;
request64.parser = parser94;
org.jsoup.Connection connection97 = httpConnection50.parser(parser94);
org.jsoup.Connection connection98 = httpConnection0.parser(parser94);
org.jsoup.Connection.Request request99 = httpConnection0.request();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
org.junit.Assert.assertTrue("'" + method22 + "' != '" + org.jsoup.Connection.Method.GET + "'", method22.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + true + "'", boolean23 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection27);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 1048576 + "'", int35 == 1048576);
org.junit.Assert.assertTrue("'" + method37 + "' != '" + org.jsoup.Connection.Method.GET + "'", method37.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + true + "'", boolean38 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + false + "'", boolean42 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + true + "'", boolean43 == true);
org.junit.Assert.assertTrue("'" + method45 + "' != '" + org.jsoup.Connection.Method.GET + "'", method45.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response55);
org.junit.Assert.assertTrue("'" + method57 + "' != '" + org.jsoup.Connection.Method.GET + "'", method57.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection63);
org.junit.Assert.assertTrue("'" + method65 + "' != '" + org.jsoup.Connection.Method.GET + "'", method65.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request69);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int70 + "' != '" + 1048576 + "'", int70 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str74);
org.junit.Assert.assertTrue("'" + method76 + "' != '" + org.jsoup.Connection.Method.GET + "'", method76.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean80 + "' != '" + false + "'", boolean80 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request82);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str84);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str86);
org.junit.Assert.assertTrue("'" + method90 + "' != '" + org.jsoup.Connection.Method.GET + "'", method90.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap91);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser94);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection97);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection98);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request99);
}
@Test
public void test0668() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0668");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request4 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
request5.followRedirects = false;
boolean boolean10 = request5.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request12 = request5.timeout((int) ' ');
java.lang.String str14 = request12.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request12.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
request17.timeoutMilliseconds = 307;
org.jsoup.parser.Parser parser25 = request17.parser();
org.jsoup.Connection connection26 = httpConnection0.parser(parser25);
org.jsoup.Connection connection29 = httpConnection0.data("null=null", "null=null");
org.jsoup.Connection.Request request30 = httpConnection0.request();
org.jsoup.Connection connection33 = httpConnection0.cookie("null=null", "null=");
org.jsoup.helper.HttpConnection httpConnection34 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response35 = httpConnection34.response();
org.jsoup.Connection.Request request36 = httpConnection34.request();
org.jsoup.Connection connection38 = httpConnection34.ignoreContentType(true);
org.jsoup.Connection.Request request39 = httpConnection34.request();
org.jsoup.Connection connection41 = httpConnection34.referrer("null=hi!");
org.jsoup.helper.HttpConnection httpConnection42 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request43 = null;
org.jsoup.Connection connection44 = httpConnection42.request(request43);
org.jsoup.helper.HttpConnection httpConnection45 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response46 = httpConnection45.response();
org.jsoup.Connection.Request request47 = httpConnection45.request();
org.jsoup.Connection connection48 = httpConnection42.request(request47);
org.jsoup.helper.HttpConnection httpConnection49 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection51 = httpConnection49.followRedirects(false);
org.jsoup.Connection connection53 = httpConnection49.referrer("");
org.jsoup.Connection.Response response54 = httpConnection49.response();
org.jsoup.Connection connection55 = httpConnection42.response(response54);
org.jsoup.Connection connection57 = httpConnection42.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request58 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method59 = request58.method();
boolean boolean60 = request58.ignoreHttpErrors();
org.jsoup.Connection.Request request63 = request58.cookie("hi!", "");
java.lang.String str65 = request58.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request66 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method67 = request66.method();
boolean boolean68 = request66.followRedirects;
org.jsoup.Connection.Request request70 = request66.followRedirects(true);
java.lang.String str72 = request66.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request73 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method74 = request73.method();
org.jsoup.Connection.Request request75 = request66.method(method74);
org.jsoup.Connection.Request request76 = request58.method(method74);
org.jsoup.Connection connection77 = httpConnection42.method(method74);
org.jsoup.Connection connection79 = httpConnection42.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection80 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response81 = httpConnection80.response();
org.jsoup.Connection connection83 = httpConnection80.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection84 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response85 = httpConnection84.response();
httpConnection80.res = response85;
java.lang.String[] strArray89 = new java.lang.String[] { "null=null", "null=null" };
org.jsoup.Connection connection90 = httpConnection80.data(strArray89);
org.jsoup.Connection connection91 = httpConnection42.data(strArray89);
org.jsoup.Connection connection92 = httpConnection34.data(strArray89);
org.jsoup.Connection connection93 = httpConnection0.data(strArray89);
org.jsoup.Connection.Request request94 = httpConnection0.req;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
org.junit.Assert.assertTrue("'" + method59 + "' != '" + org.jsoup.Connection.Method.GET + "'", method59.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean60 + "' != '" + false + "'", boolean60 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str65);
org.junit.Assert.assertTrue("'" + method67 + "' != '" + org.jsoup.Connection.Method.GET + "'", method67.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean68 + "' != '" + true + "'", boolean68 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request70);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str72);
org.junit.Assert.assertTrue("'" + method74 + "' != '" + org.jsoup.Connection.Method.GET + "'", method74.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection79);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response81);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection83);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response85);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray89);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection90);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection91);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection92);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection93);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request94);
}
@Test
public void test0669() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0669");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
}
@Test
public void test0670() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0670");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("null=", "null=null=null=hi!");
keyVal2.value = "null=null";
keyVal2.value = "hi!=";
}
@Test
public void test0671() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0671");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.referrer("");
org.jsoup.Connection.Response response5 = httpConnection0.response();
org.jsoup.Connection connection7 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection9 = httpConnection0.ignoreHttpErrors(true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
}
@Test
public void test0672() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0672");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
java.lang.String str6 = request0.cookie("");
boolean boolean7 = request0.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request8.headers();
request8.followRedirects = false;
boolean boolean13 = request8.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection14 = request8.data();
request0.data = keyValCollection14;
org.jsoup.helper.HttpConnection.KeyVal keyVal18 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = keyVal18.key("null=null");
org.jsoup.helper.HttpConnection.Request request21 = request0.data((org.jsoup.Connection.KeyVal) keyVal20);
java.lang.String str23 = request0.header("null=null=hi!");
boolean boolean25 = request0.hasHeader("hi!=");
org.jsoup.Connection.Request request27 = request0.removeCookie("hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
}
@Test
public void test0673() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0673");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
int int12 = request7.maxBodySize();
java.lang.String str14 = request7.header("hi!");
boolean boolean15 = request7.followRedirects();
boolean boolean16 = request7.ignoreHttpErrors;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
}
@Test
public void test0674() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0674");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.lang.String str8 = response1.cookie("");
java.lang.String str10 = response1.header("null=null");
java.lang.String str11 = response1.statusMessage();
response1.statusMessage = "hi!=null";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
}
@Test
public void test0675() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0675");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
java.net.URL uRL7 = request0.url();
boolean boolean8 = request0.followRedirects;
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str10 = keyVal9.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal12 = keyVal9.value("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal14 = keyVal9.key("hi!");
java.lang.String str15 = keyVal9.value;
org.jsoup.helper.HttpConnection.Request request16 = request0.data((org.jsoup.Connection.KeyVal) keyVal9);
request0.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser19 = request0.parser;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str15 + "' != '" + "hi!" + "'", str15.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser19);
}
@Test
public void test0676() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0676");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.util.Map<java.lang.String, java.lang.String> strMap7 = response1.cookies();
java.net.HttpURLConnection httpURLConnection8 = null;
org.jsoup.helper.HttpConnection.Response response9 = null;
org.jsoup.helper.HttpConnection.Response response10 = new org.jsoup.helper.HttpConnection.Response(response9);
java.lang.String str11 = response10.contentType();
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection8, (org.jsoup.Connection.Response) response10);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
}
@Test
public void test0677() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0677");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
response1.statusMessage = "hi!=null";
boolean boolean11 = response1.hasCookie("hi!=");
org.jsoup.Connection.Response response14 = response1.header("hi!=", "hi!=");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response16 = response1.removeHeader("");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response14);
}
@Test
public void test0678() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0678");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.maxBodySize((int) (short) 1);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request6 = null;
org.jsoup.Connection connection7 = httpConnection5.request(request6);
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
org.jsoup.Connection.Request request10 = httpConnection8.request();
org.jsoup.Connection connection11 = httpConnection5.request(request10);
org.jsoup.Connection connection14 = httpConnection5.cookie("null=null", "null=null");
org.jsoup.Connection connection16 = httpConnection5.followRedirects(true);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.cookies();
org.jsoup.Connection connection23 = httpConnection5.data(strMap22);
org.jsoup.Connection connection24 = httpConnection0.data(strMap22);
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.followRedirects = false;
java.lang.String str31 = request25.cookie("");
boolean boolean32 = request25.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
java.util.Map<java.lang.String, java.lang.String> strMap35 = request33.headers();
request33.followRedirects = false;
boolean boolean38 = request33.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection39 = request33.data();
request25.data = keyValCollection39;
org.jsoup.helper.HttpConnection.KeyVal keyVal43 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = keyVal43.key("null=null");
org.jsoup.helper.HttpConnection.Request request46 = request25.data((org.jsoup.Connection.KeyVal) keyVal45);
org.jsoup.helper.HttpConnection.Request request47 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method48 = request47.method();
java.util.Map<java.lang.String, java.lang.String> strMap49 = request47.headers();
request47.followRedirects = false;
boolean boolean52 = request47.ignoreHttpErrors;
org.jsoup.Connection.Method method53 = request47.method();
int int54 = request47.maxBodySizeBytes;
org.jsoup.Connection.Method method55 = request47.method();
org.jsoup.Connection.Request request56 = request25.method(method55);
org.jsoup.Connection connection57 = httpConnection0.request((org.jsoup.Connection.Request) request25);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection59 = httpConnection0.url("null=null=hi!");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Malformed URL: null=null=hi!");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + false + "'", boolean38 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
org.junit.Assert.assertTrue("'" + method48 + "' != '" + org.jsoup.Connection.Method.GET + "'", method48.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + false + "'", boolean52 == false);
org.junit.Assert.assertTrue("'" + method53 + "' != '" + org.jsoup.Connection.Method.GET + "'", method53.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 1048576 + "'", int54 == 1048576);
org.junit.Assert.assertTrue("'" + method55 + "' != '" + org.jsoup.Connection.Method.GET + "'", method55.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
}
@Test
public void test0679() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0679");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry5 = request0.scanHeaders("hi!");
java.util.Map<java.lang.String, java.lang.String> strMap6 = request0.headers();
java.net.URL uRL7 = request0.url();
int int8 = request0.maxBodySizeBytes;
java.lang.String str10 = request0.header("null=null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 1048576 + "'", int8 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
}
@Test
public void test0680() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0680");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
request7.followRedirects = false;
boolean boolean12 = request7.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request14 = request7.timeout((int) ' ');
java.lang.String str16 = request14.cookie("hi!");
java.lang.String str18 = request14.header("null=null");
request14.followRedirects = false;
org.jsoup.parser.Parser parser21 = request14.parser;
org.jsoup.Connection connection22 = httpConnection0.parser(parser21);
org.jsoup.helper.HttpConnection.Response response23 = null;
org.jsoup.helper.HttpConnection.Response response24 = new org.jsoup.helper.HttpConnection.Response(response23);
int int25 = response24.numRedirects;
response24.charset = "hi!=null";
response24.statusMessage = "null=";
org.jsoup.Connection connection30 = httpConnection0.response((org.jsoup.Connection.Response) response24);
org.jsoup.Connection.Response response31 = null;
org.jsoup.Connection connection32 = httpConnection0.response(response31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int25 + "' != '" + 0 + "'", int25 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
}
@Test
public void test0681() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0681");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
int int19 = request18.timeout();
request18.maxBodySizeBytes = 3000;
org.jsoup.Connection.Request request24 = request18.header("hi!", "hi!=null");
java.util.Map<java.lang.String, java.lang.String> strMap25 = request18.headers();
java.net.URL uRL26 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request27 = request18.url(uRL26);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 3000 + "'", int19 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap25);
}
@Test
public void test0682() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0682");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
org.jsoup.parser.Parser parser6 = null;
request0.parser = parser6;
request0.timeoutMilliseconds = (short) 1;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
}
@Test
public void test0683() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0683");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "");
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = keyVal2.key("null=null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal4.value("hi!=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal8 = keyVal4.key("null=null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal4.value("null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
}
@Test
public void test0684() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0684");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
org.jsoup.Connection.Request request21 = request0.cookie("null=hi!", "null=null=null=hi!");
org.jsoup.Connection.Request request23 = request0.removeCookie("null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
}
@Test
public void test0685() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0685");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = request0.scanHeaders("hi!");
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request10.headers();
request10.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser15 = request10.parser;
org.jsoup.helper.HttpConnection.Request request16 = request0.parser(parser15);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
}
@Test
public void test0686() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0686");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.Connection.Request request3 = httpConnection0.req;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection6 = httpConnection0.data("hi!=null", "null=hi!");
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request3);
}
@Test
public void test0687() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0687");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Request request7 = request0.maxBodySize((int) (short) 0);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
}
@Test
public void test0688() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0688");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
boolean boolean18 = request16.followRedirects;
org.jsoup.Connection.Request request20 = request16.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap21 = request16.cookies();
org.jsoup.Connection connection22 = httpConnection0.cookies(strMap21);
org.jsoup.helper.HttpConnection httpConnection23 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection25 = httpConnection23.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.followRedirects = false;
boolean boolean31 = request26.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request33 = request26.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry35 = request26.scanHeaders("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap36 = request26.headers();
org.jsoup.Connection connection37 = httpConnection23.data(strMap36);
org.jsoup.Connection.Response response38 = httpConnection23.res;
org.jsoup.Connection connection39 = httpConnection0.response(response38);
org.jsoup.Connection connection42 = httpConnection0.data("hi!=null=hi!=null", "hi!=null=hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + true + "'", boolean18 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
}
@Test
public void test0689() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0689");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
java.util.Map<java.lang.String, java.lang.String> strMap4 = request2.headers();
request2.followRedirects = false;
boolean boolean7 = request2.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request9 = request2.timeout((int) ' ');
boolean boolean10 = request9.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal13.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal19 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal21 = keyVal19.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal22 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal22.key = "hi!";
java.lang.String str25 = keyVal22.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal27 = keyVal22.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal30 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal31 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal31.key = "hi!";
java.lang.String str34 = keyVal31.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str36 = keyVal35.toString();
keyVal35.value = "";
keyVal35.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal41 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal41.key = "hi!";
java.lang.String str44 = keyVal41.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal46 = keyVal41.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal47 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str48 = keyVal47.key();
org.jsoup.Connection.KeyVal[] keyValArray49 = new org.jsoup.Connection.KeyVal[] { keyVal13, keyVal16, keyVal21, keyVal22, keyVal30, keyVal31, keyVal35, keyVal41, keyVal47 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList50 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean51 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList50, keyValArray49);
request9.data = keyValList50;
org.jsoup.helper.HttpConnection.Request request53 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method54 = request53.method();
java.util.Map<java.lang.String, java.lang.String> strMap55 = request53.headers();
request53.followRedirects = false;
java.lang.String str59 = request53.cookie("");
boolean boolean60 = request53.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request61 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method62 = request61.method();
java.util.Map<java.lang.String, java.lang.String> strMap63 = request61.headers();
request61.followRedirects = false;
boolean boolean66 = request61.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection67 = request61.data();
request53.data = keyValCollection67;
request9.data = keyValCollection67;
org.jsoup.Connection connection70 = httpConnection0.data(keyValCollection67);
org.jsoup.helper.HttpConnection httpConnection71 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response72 = httpConnection71.response();
org.jsoup.Connection connection74 = httpConnection71.maxBodySize((int) (short) 0);
org.jsoup.helper.HttpConnection httpConnection75 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response76 = httpConnection75.response();
httpConnection71.res = response76;
org.jsoup.Connection connection80 = httpConnection71.header("hi!", "");
java.lang.String[] strArray87 = new java.lang.String[] { "null=null=null=hi!", "null=null=null=hi!", "null=null", "null=hi!", "null=null", "null=null" };
org.jsoup.Connection connection88 = httpConnection71.data(strArray87);
org.jsoup.Connection connection89 = httpConnection0.data(strArray87);
org.jsoup.Connection connection91 = httpConnection0.ignoreHttpErrors(true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str25 + "' != '" + "hi!" + "'", str25.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str34 + "' != '" + "hi!" + "'", str34.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str36 + "' != '" + "null=null" + "'", str36.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str44 + "' != '" + "hi!" + "'", str44.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean51 + "' != '" + true + "'", boolean51 == true);
org.junit.Assert.assertTrue("'" + method54 + "' != '" + org.jsoup.Connection.Method.GET + "'", method54.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean60 + "' != '" + false + "'", boolean60 == false);
org.junit.Assert.assertTrue("'" + method62 + "' != '" + org.jsoup.Connection.Method.GET + "'", method62.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean66 + "' != '" + false + "'", boolean66 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection70);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray87);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection88);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection89);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection91);
}
@Test
public void test0690() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0690");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("null=null=null=hi!", "hi!");
java.lang.String str3 = keyVal2.value;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "hi!" + "'", str3.equals("hi!"));
}
@Test
public void test0691() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0691");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection connection4 = httpConnection0.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap6 = request5.headers();
httpConnection0.req = request5;
org.jsoup.Connection.Method method8 = request5.method();
boolean boolean10 = request5.hasHeader("hi!=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
}
@Test
public void test0692() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0692");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.followRedirects();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry10 = request7.scanHeaders("");
request7.ignoreContentType = false;
org.jsoup.Connection.Method method13 = request7.method();
org.jsoup.Connection.Request request15 = request7.removeHeader("hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry10);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
}
@Test
public void test0693() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0693");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal11 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal11.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal14 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal17 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal19 = keyVal17.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal20.key = "hi!";
java.lang.String str23 = keyVal20.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal25 = keyVal20.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal28 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal29 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal29.key = "hi!";
java.lang.String str32 = keyVal29.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal33 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str34 = keyVal33.toString();
keyVal33.value = "";
keyVal33.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal39.key = "hi!";
java.lang.String str42 = keyVal39.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal44 = keyVal39.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str46 = keyVal45.key();
org.jsoup.Connection.KeyVal[] keyValArray47 = new org.jsoup.Connection.KeyVal[] { keyVal11, keyVal14, keyVal19, keyVal20, keyVal28, keyVal29, keyVal33, keyVal39, keyVal45 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList48 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean49 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList48, keyValArray47);
request7.data = keyValList48;
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
java.util.Map<java.lang.String, java.lang.String> strMap53 = request51.headers();
request51.followRedirects = false;
java.lang.String str57 = request51.cookie("");
boolean boolean58 = request51.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request59 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method60 = request59.method();
java.util.Map<java.lang.String, java.lang.String> strMap61 = request59.headers();
request59.followRedirects = false;
boolean boolean64 = request59.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection65 = request59.data();
request51.data = keyValCollection65;
request7.data = keyValCollection65;
org.jsoup.Connection.Request request70 = request7.cookie("hi!=null", "null=null=hi!");
int int71 = request7.maxBodySize();
org.jsoup.Connection.Request request73 = request7.removeCookie("hi!=null=hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str23 + "' != '" + "hi!" + "'", str23.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str32 + "' != '" + "hi!" + "'", str32.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str34 + "' != '" + "null=null" + "'", str34.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str42 + "' != '" + "hi!" + "'", str42.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean49 + "' != '" + true + "'", boolean49 == true);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean58 + "' != '" + false + "'", boolean58 == false);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean64 + "' != '" + false + "'", boolean64 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request70);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int71 + "' != '" + 1048576 + "'", int71 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request73);
}
@Test
public void test0694() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0694");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = response1.scanHeaders("hi!=");
int int18 = response1.numRedirects;
boolean boolean19 = response1.executed;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response20 = new org.jsoup.helper.HttpConnection.Response(response1);
org.junit.Assert.fail("Expected exception of type java.io.IOException; message: Too many redirects occurred trying to load URL null");
} catch (java.io.IOException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + false + "'", boolean19 == false);
}
@Test
public void test0695() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0695");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!";
// The following exception was thrown during execution in test generation
try {
java.lang.String str5 = response1.body();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before getting response body");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
}
@Test
public void test0696() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0696");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = request0.scanHeaders("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection10 = request0.data;
java.lang.String str12 = request0.header("null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
}
@Test
public void test0697() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0697");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection.Request request7 = httpConnection0.req;
org.jsoup.Connection connection9 = httpConnection0.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
request10.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap19 = request10.cookies();
httpConnection0.req = request10;
org.jsoup.Connection.Response response21 = httpConnection0.response();
org.jsoup.helper.HttpConnection httpConnection22 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response23 = httpConnection22.response();
org.jsoup.Connection connection25 = httpConnection22.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection26 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response27 = httpConnection26.response();
httpConnection22.res = response27;
org.jsoup.helper.HttpConnection.Request request29 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap30 = request29.headers();
org.jsoup.Connection connection31 = httpConnection22.request((org.jsoup.Connection.Request) request29);
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
org.jsoup.helper.HttpConnection.Request request34 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method35 = request34.method();
boolean boolean36 = request34.followRedirects;
org.jsoup.Connection.Request request38 = request34.followRedirects(true);
java.lang.String str40 = request34.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request41 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method42 = request41.method();
org.jsoup.Connection.Request request43 = request34.method(method42);
org.jsoup.Connection.Request request44 = request32.method(method42);
org.jsoup.Connection.Request request45 = request29.method(method42);
org.jsoup.Connection connection46 = httpConnection0.method(method42);
org.jsoup.Connection connection48 = httpConnection0.referrer("null=null=null=hi!");
org.jsoup.Connection.Response response49 = httpConnection0.res;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection31);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method35 + "' != '" + org.jsoup.Connection.Method.GET + "'", method35.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + true + "'", boolean36 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str40);
org.junit.Assert.assertTrue("'" + method42 + "' != '" + org.jsoup.Connection.Method.GET + "'", method42.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response49);
}
@Test
public void test0698() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0698");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request10.headers();
int int13 = request10.timeout();
org.jsoup.parser.Parser parser14 = request10.parser();
org.jsoup.helper.HttpConnection.Request request15 = request7.parser(parser14);
boolean boolean16 = request7.ignoreHttpErrors;
org.jsoup.Connection.Request request18 = request7.ignoreHttpErrors(false);
request7.ignoreContentType = true;
boolean boolean21 = request7.ignoreHttpErrors;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 3000 + "'", int13 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
}
@Test
public void test0699() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0699");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.req;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection4 = httpConnection0.timeout((int) (short) -1);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Timeout milliseconds must be 0 (infinite) or greater");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
}
@Test
public void test0700() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0700");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.parser.Parser parser13 = request0.parser;
org.jsoup.Connection.Request request15 = request0.removeHeader("null=null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap16 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap17 = request0.cookies();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
}
@Test
public void test0701() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0701");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
java.lang.String str7 = response1.statusMessage;
response1.executed = true;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
}
@Test
public void test0702() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0702");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
keyVal3.value = "";
keyVal3.value = "hi!";
java.lang.String str8 = keyVal3.key();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
}
@Test
public void test0703() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0703");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = response1.scanHeaders("hi!=");
int int18 = response1.numRedirects;
java.net.URL uRL19 = response1.url();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL19);
}
@Test
public void test0704() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0704");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Request request2 = request0.removeHeader("null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
}
@Test
public void test0705() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0705");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap1 = request0.headers();
boolean boolean2 = request0.followRedirects;
int int3 = request0.timeoutMilliseconds;
java.lang.String str5 = request0.cookie("null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap6 = request0.headers();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3000 + "'", int3 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
}
@Test
public void test0706() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0706");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.lang.String str2 = response1.contentType();
java.net.URL uRL3 = response1.url();
java.lang.String str5 = response1.cookie("null=null=null=hi!=hi!");
java.net.HttpURLConnection httpURLConnection6 = null;
org.jsoup.helper.HttpConnection.Response response7 = null;
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response7);
int int9 = response8.statusCode();
int int10 = response8.numRedirects;
response8.charset = "";
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
java.util.Map<java.lang.String, java.lang.String> strMap15 = request13.headers();
request13.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
boolean boolean20 = request18.ignoreHttpErrors();
org.jsoup.Connection.Request request23 = request18.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
java.util.Map<java.lang.String, java.lang.String> strMap26 = request24.headers();
request24.followRedirects = false;
boolean boolean29 = request24.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request31 = request24.timeout((int) ' ');
java.lang.String str33 = request31.cookie("hi!");
java.lang.String str35 = request31.header("null=null");
request31.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request38 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method39 = request38.method();
java.util.Map<java.lang.String, java.lang.String> strMap40 = request38.headers();
request38.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser43 = request38.parser;
request31.parser = parser43;
org.jsoup.helper.HttpConnection.Request request45 = request18.parser(parser43);
org.jsoup.helper.HttpConnection.Request request46 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method47 = request46.method();
org.jsoup.Connection.Request request48 = request45.method(method47);
org.jsoup.Connection.Request request49 = request13.method(method47);
org.jsoup.Connection.Response response50 = response8.method(method47);
org.jsoup.Connection.Request request51 = response8.req;
response8.statusCode = (byte) 10;
java.util.Map<java.lang.String, java.lang.String> strMap54 = response8.headers();
int int55 = response8.statusCode;
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection6, (org.jsoup.Connection.Response) response8);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 0 + "'", int10 == 0);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + false + "'", boolean29 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str35);
org.junit.Assert.assertTrue("'" + method39 + "' != '" + org.jsoup.Connection.Method.GET + "'", method39.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
org.junit.Assert.assertTrue("'" + method47 + "' != '" + org.jsoup.Connection.Method.GET + "'", method47.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int55 + "' != '" + 10 + "'", int55 == 10);
}
@Test
public void test0707() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0707");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection3 = httpConnection0.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request4 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method5 = request4.method();
java.util.Map<java.lang.String, java.lang.String> strMap6 = request4.headers();
int int7 = request4.timeout();
org.jsoup.parser.Parser parser8 = request4.parser();
org.jsoup.Connection connection9 = httpConnection0.parser(parser8);
org.jsoup.helper.HttpConnection httpConnection10 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response11 = httpConnection10.response();
org.jsoup.Connection connection13 = httpConnection10.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection14 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response15 = httpConnection14.response();
httpConnection10.res = response15;
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap18 = request17.headers();
org.jsoup.Connection connection19 = httpConnection10.request((org.jsoup.Connection.Request) request17);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry21 = request17.scanHeaders("null=null");
org.jsoup.Connection.Request request23 = request17.ignoreContentType(false);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection24 = request17.data;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
org.jsoup.Connection.Request request28 = request25.ignoreContentType(false);
org.jsoup.Connection.Request request30 = request25.removeCookie("");
int int31 = request25.maxBodySize();
org.jsoup.Connection.Request request33 = request25.followRedirects(false);
java.lang.String str35 = request25.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request36 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method37 = request36.method();
java.util.Map<java.lang.String, java.lang.String> strMap38 = request36.headers();
request36.followRedirects = false;
boolean boolean41 = request36.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request43 = request36.timeout((int) ' ');
java.lang.String str45 = request43.cookie("hi!");
java.lang.String str47 = request43.header("null=null");
request43.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
java.util.Map<java.lang.String, java.lang.String> strMap52 = request50.headers();
request50.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser55 = request50.parser;
request43.parser = parser55;
request25.parser = parser55;
org.jsoup.helper.HttpConnection.Request request58 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method59 = request58.method();
boolean boolean60 = request58.ignoreHttpErrors();
org.jsoup.Connection.Request request63 = request58.cookie("hi!", "");
boolean boolean64 = request58.ignoreContentType;
org.jsoup.parser.Parser parser65 = request58.parser();
request25.parser = parser65;
request17.parser = parser65;
org.jsoup.Connection connection68 = httpConnection0.parser(parser65);
org.jsoup.Connection connection70 = httpConnection0.userAgent("null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
org.junit.Assert.assertTrue("'" + method5 + "' != '" + org.jsoup.Connection.Method.GET + "'", method5.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 3000 + "'", int7 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection24);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 1048576 + "'", int31 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str35);
org.junit.Assert.assertTrue("'" + method37 + "' != '" + org.jsoup.Connection.Method.GET + "'", method37.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean41 + "' != '" + false + "'", boolean41 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str47);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser55);
org.junit.Assert.assertTrue("'" + method59 + "' != '" + org.jsoup.Connection.Method.GET + "'", method59.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean60 + "' != '" + false + "'", boolean60 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean64 + "' != '" + false + "'", boolean64 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection68);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection70);
}
@Test
public void test0708() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0708");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection.Request request18 = httpConnection0.req;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
}
@Test
public void test0709() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0709");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
boolean boolean8 = request0.hasHeader("null=null=hi!");
java.lang.String str10 = request0.header("hi!=null");
org.jsoup.Connection.Request request12 = request0.ignoreHttpErrors(true);
org.jsoup.Connection.Method method13 = request0.method();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
}
@Test
public void test0710() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0710");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
boolean boolean7 = response1.hasHeader("hi!=");
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response1);
org.junit.Assert.fail("Expected exception of type java.io.IOException; message: Too many redirects occurred trying to load URL null");
} catch (java.io.IOException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
}
@Test
public void test0711() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0711");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal0.key = "hi!";
java.lang.String str3 = keyVal0.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal0.key("hi!");
java.lang.String str6 = keyVal0.value();
keyVal0.key = "null=";
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal0.value("null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal12 = keyVal10.value("null=null=null=hi!=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "hi!" + "'", str3.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal12);
}
@Test
public void test0712() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0712");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
org.jsoup.Connection.Request request7 = request0.removeCookie("null=");
java.lang.Class<?> wildcardClass8 = request0.getClass();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(wildcardClass8);
}
@Test
public void test0713() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0713");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.toString();
keyVal0.value = "";
java.lang.String str4 = keyVal0.key();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "null=null" + "'", str1.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
}
@Test
public void test0714() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0714");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.referrer("");
org.jsoup.Connection.Response response5 = httpConnection0.response();
org.jsoup.Connection connection7 = httpConnection0.followRedirects(false);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection9 = httpConnection0.url("null=null=");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Malformed URL: null=null=");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
}
@Test
public void test0715() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0715");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
org.jsoup.Connection.Request request16 = request0.removeCookie("");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection17 = request0.data();
org.jsoup.Connection.Request request20 = request0.header("null=hi!", "");
org.jsoup.helper.HttpConnection httpConnection21 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response22 = httpConnection21.response();
org.jsoup.Connection connection24 = httpConnection21.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection25 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response26 = httpConnection25.response();
httpConnection21.res = response26;
org.jsoup.helper.HttpConnection.Request request28 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method29 = request28.method();
java.util.Map<java.lang.String, java.lang.String> strMap30 = request28.headers();
request28.followRedirects = false;
boolean boolean33 = request28.ignoreHttpErrors;
org.jsoup.Connection.Method method34 = request28.method();
org.jsoup.Connection connection35 = httpConnection21.method(method34);
org.jsoup.Connection.Request request36 = request0.method(method34);
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
boolean boolean39 = request37.ignoreHttpErrors();
org.jsoup.Connection.Request request42 = request37.cookie("hi!", "");
boolean boolean43 = request37.ignoreContentType;
org.jsoup.Connection.Request request46 = request37.cookie("null=hi!", "hi!");
java.lang.String str48 = request37.getHeaderCaseInsensitive("");
java.lang.String str50 = request37.cookie("");
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
java.util.Map<java.lang.String, java.lang.String> strMap53 = request51.headers();
request51.followRedirects = false;
boolean boolean56 = request51.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request58 = request51.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry60 = request51.scanHeaders("null=null");
org.jsoup.Connection.Request request62 = request51.ignoreContentType(false);
org.jsoup.helper.HttpConnection.Request request63 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method64 = request63.method();
boolean boolean65 = request63.ignoreHttpErrors();
org.jsoup.Connection.Request request68 = request63.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request69 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method70 = request69.method();
java.util.Map<java.lang.String, java.lang.String> strMap71 = request69.headers();
request69.followRedirects = false;
boolean boolean74 = request69.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request76 = request69.timeout((int) ' ');
java.lang.String str78 = request76.cookie("hi!");
java.lang.String str80 = request76.header("null=null");
request76.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request83 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method84 = request83.method();
java.util.Map<java.lang.String, java.lang.String> strMap85 = request83.headers();
request83.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser88 = request83.parser;
request76.parser = parser88;
org.jsoup.helper.HttpConnection.Request request90 = request63.parser(parser88);
org.jsoup.helper.HttpConnection.Request request91 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method92 = request91.method();
org.jsoup.Connection.Request request93 = request90.method(method92);
org.jsoup.Connection.Request request94 = request51.method(method92);
org.jsoup.Connection.Request request95 = request37.method(method92);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection96 = request37.data();
request0.data = keyValCollection96;
boolean boolean98 = request0.followRedirects;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response26);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean39 + "' != '" + false + "'", boolean39 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + false + "'", boolean43 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str50);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + false + "'", boolean56 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request62);
org.junit.Assert.assertTrue("'" + method64 + "' != '" + org.jsoup.Connection.Method.GET + "'", method64.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean65 + "' != '" + false + "'", boolean65 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request68);
org.junit.Assert.assertTrue("'" + method70 + "' != '" + org.jsoup.Connection.Method.GET + "'", method70.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean74 + "' != '" + false + "'", boolean74 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str78);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str80);
org.junit.Assert.assertTrue("'" + method84 + "' != '" + org.jsoup.Connection.Method.GET + "'", method84.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap85);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser88);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request90);
org.junit.Assert.assertTrue("'" + method92 + "' != '" + org.jsoup.Connection.Method.GET + "'", method92.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request93);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request94);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request95);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection96);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean98 + "' != '" + true + "'", boolean98 == true);
}
@Test
public void test0716() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0716");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.util.Map<java.lang.String, java.lang.String> strMap7 = response1.cookies();
org.jsoup.Connection.Response response10 = response1.cookie("hi!=", "hi!");
java.lang.String str11 = response1.charset;
java.lang.String str12 = response1.charset;
java.lang.String str13 = response1.statusMessage;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str13);
}
@Test
public void test0717() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0717");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
response1.statusCode = (short) -1;
java.util.Map<java.lang.String, java.lang.String> strMap9 = response1.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
boolean boolean17 = request10.followRedirects();
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
org.jsoup.Connection.Request request20 = request10.method(method19);
org.jsoup.Connection.Response response21 = response1.method(method19);
java.lang.String str22 = response1.charset();
int int23 = response1.statusCode;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int23 + "' != '" + (-1) + "'", int23 == (-1));
}
@Test
public void test0718() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0718");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
// The following exception was thrown during execution in test generation
try {
java.lang.String str4 = response1.body();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before getting response body");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
}
@Test
public void test0719() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0719");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
java.lang.String str6 = request0.cookie("");
org.jsoup.Connection.Request request8 = request0.maxBodySize((int) (short) 100);
boolean boolean9 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Response response10 = null;
org.jsoup.helper.HttpConnection.Response response11 = new org.jsoup.helper.HttpConnection.Response(response10);
int int12 = response11.statusCode();
int int13 = response11.numRedirects;
response11.charset = "";
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
java.util.Map<java.lang.String, java.lang.String> strMap18 = request16.headers();
request16.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request21 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method22 = request21.method();
boolean boolean23 = request21.ignoreHttpErrors();
org.jsoup.Connection.Request request26 = request21.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request27 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method28 = request27.method();
java.util.Map<java.lang.String, java.lang.String> strMap29 = request27.headers();
request27.followRedirects = false;
boolean boolean32 = request27.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request34 = request27.timeout((int) ' ');
java.lang.String str36 = request34.cookie("hi!");
java.lang.String str38 = request34.header("null=null");
request34.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request41 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method42 = request41.method();
java.util.Map<java.lang.String, java.lang.String> strMap43 = request41.headers();
request41.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser46 = request41.parser;
request34.parser = parser46;
org.jsoup.helper.HttpConnection.Request request48 = request21.parser(parser46);
org.jsoup.helper.HttpConnection.Request request49 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method50 = request49.method();
org.jsoup.Connection.Request request51 = request48.method(method50);
org.jsoup.Connection.Request request52 = request16.method(method50);
org.jsoup.Connection.Response response53 = response11.method(method50);
org.jsoup.Connection.Request request54 = response11.req;
response11.statusCode = (byte) 10;
java.util.Map<java.lang.String, java.lang.String> strMap57 = response11.headers();
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response58 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request0, response11);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 0 + "'", int13 == 0);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
org.junit.Assert.assertTrue("'" + method22 + "' != '" + org.jsoup.Connection.Method.GET + "'", method22.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request26);
org.junit.Assert.assertTrue("'" + method28 + "' != '" + org.jsoup.Connection.Method.GET + "'", method28.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str38);
org.junit.Assert.assertTrue("'" + method42 + "' != '" + org.jsoup.Connection.Method.GET + "'", method42.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
org.junit.Assert.assertTrue("'" + method50 + "' != '" + org.jsoup.Connection.Method.GET + "'", method50.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap57);
}
@Test
public void test0720() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0720");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean9 = request3.hasCookie("null=null");
java.lang.String str11 = request3.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection connection12 = httpConnection0.request((org.jsoup.Connection.Request) request3);
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
java.util.Map<java.lang.String, java.lang.String> strMap15 = request13.headers();
request13.followRedirects = false;
boolean boolean18 = request13.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request20 = request13.timeout((int) ' ');
boolean boolean21 = request20.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap22 = request20.headers();
org.jsoup.Connection connection23 = httpConnection0.cookies(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + false + "'", boolean18 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
}
@Test
public void test0721() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0721");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request10.headers();
int int13 = request10.timeout();
org.jsoup.parser.Parser parser14 = request10.parser();
org.jsoup.helper.HttpConnection.Request request15 = request7.parser(parser14);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = request15.scanHeaders("hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 3000 + "'", int13 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
}
@Test
public void test0722() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0722");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection.Request request7 = httpConnection0.req;
org.jsoup.Connection connection9 = httpConnection0.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
request10.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap19 = request10.cookies();
httpConnection0.req = request10;
boolean boolean22 = request10.hasCookie("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request23 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method24 = request23.method();
java.util.Map<java.lang.String, java.lang.String> strMap25 = request23.headers();
request23.followRedirects = false;
boolean boolean28 = request23.ignoreHttpErrors;
org.jsoup.Connection.Method method29 = request23.method();
int int30 = request23.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
boolean boolean33 = request31.followRedirects;
org.jsoup.Connection.Request request35 = request31.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap36 = request31.headers();
boolean boolean37 = request31.ignoreContentType;
boolean boolean38 = request31.followRedirects();
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request31.method(method40);
org.jsoup.Connection.Request request42 = request23.method(method40);
org.jsoup.Connection.Request request43 = request10.method(method40);
request10.ignoreHttpErrors = false;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
org.junit.Assert.assertTrue("'" + method24 + "' != '" + org.jsoup.Connection.Method.GET + "'", method24.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 1048576 + "'", int30 == 1048576);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + true + "'", boolean33 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + true + "'", boolean38 == true);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
}
@Test
public void test0723() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0723");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection10 = request7.data();
java.lang.String str12 = request7.header("hi!");
org.jsoup.Connection.Request request15 = request7.cookie("null=null=null=hi!", "null=null");
boolean boolean17 = request7.hasCookie("null=");
java.net.URL uRL18 = request7.url();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL18);
}
@Test
public void test0724() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0724");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str6 = response1.statusMessage;
response1.charset = "hi!=";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
}
@Test
public void test0725() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0725");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap1 = request0.headers();
org.jsoup.Connection.Request request3 = request0.removeHeader("null=null=null=hi!");
java.net.URL uRL4 = request0.url();
int int5 = request0.maxBodySizeBytes;
org.jsoup.Connection.Request request7 = request0.ignoreHttpErrors(false);
org.jsoup.Connection.Request request9 = request0.removeCookie("hi!");
org.jsoup.helper.HttpConnection.Response response10 = null;
org.jsoup.helper.HttpConnection.Response response11 = new org.jsoup.helper.HttpConnection.Response(response10);
int int12 = response11.numRedirects;
response11.charset = "hi!=null";
response11.statusMessage = "null=";
int int17 = response11.statusCode;
response11.executed = false;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response20 = org.jsoup.helper.HttpConnection.Response.execute(request9, response11);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 1048576 + "'", int5 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 0 + "'", int17 == 0);
}
@Test
public void test0726() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0726");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.Connection.Response response7 = response1.removeHeader("hi!");
boolean boolean9 = response1.hasHeader("hi!=");
boolean boolean10 = response1.executed;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
}
@Test
public void test0727() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0727");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry20 = request18.scanHeaders("");
boolean boolean21 = request18.followRedirects;
java.util.Map<java.lang.String, java.lang.String> strMap22 = request18.cookies();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection23 = request18.data;
boolean boolean24 = request18.ignoreContentType();
request18.timeoutMilliseconds = 100;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
}
@Test
public void test0728() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0728");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
org.jsoup.Connection.Response response8 = response1.header("null=null=hi!", "null=null=hi!");
java.lang.String str10 = response1.getHeaderCaseInsensitive("null=hi!");
java.lang.String str11 = response1.statusMessage();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
}
@Test
public void test0729() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0729");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.cookies();
boolean boolean4 = request0.followRedirects();
request0.timeoutMilliseconds = (byte) 0;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
}
@Test
public void test0730() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0730");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
request0.maxBodySizeBytes = (-1);
java.lang.String str4 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
java.lang.String str6 = request0.cookie("hi!=null=hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
}
@Test
public void test0731() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0731");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request0.followRedirects();
org.jsoup.Connection.Method method9 = request0.method();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
}
@Test
public void test0732() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0732");
org.jsoup.helper.HttpConnection.Response.MAX_REDIRECTS = ' ';
}
@Test
public void test0733() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0733");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal0.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = keyVal5.value("null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
}
@Test
public void test0734() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0734");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
java.lang.String str3 = response1.contentType();
boolean boolean5 = response1.hasCookie("null=null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap6 = response1.cookies();
int int7 = response1.statusCode();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
}
@Test
public void test0735() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0735");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.parser.Parser parser3 = null;
org.jsoup.Connection connection4 = httpConnection0.parser(parser3);
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry11 = request6.scanHeaders("hi!");
java.util.Map<java.lang.String, java.lang.String> strMap12 = request6.headers();
org.jsoup.Connection connection13 = httpConnection0.data(strMap12);
org.jsoup.helper.HttpConnection.Request request14 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method15 = request14.method();
org.jsoup.Connection.Request request17 = request14.ignoreContentType(false);
org.jsoup.Connection.Request request19 = request14.removeCookie("");
int int20 = request14.maxBodySize();
org.jsoup.Connection.Request request22 = request14.followRedirects(false);
java.lang.String str24 = request14.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.followRedirects = false;
boolean boolean30 = request25.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request32 = request25.timeout((int) ' ');
java.lang.String str34 = request32.cookie("hi!");
java.lang.String str36 = request32.header("null=null");
request32.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
java.util.Map<java.lang.String, java.lang.String> strMap41 = request39.headers();
request39.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser44 = request39.parser;
request32.parser = parser44;
request14.parser = parser44;
org.jsoup.Connection connection47 = httpConnection0.parser(parser44);
org.jsoup.Connection connection49 = httpConnection0.referrer("null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
org.junit.Assert.assertTrue("'" + method15 + "' != '" + org.jsoup.Connection.Method.GET + "'", method15.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 1048576 + "'", int20 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str24);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean30 + "' != '" + false + "'", boolean30 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str36);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection49);
}
@Test
public void test0736() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0736");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean8 = request3.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request10 = request3.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry12 = request3.scanHeaders("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap13 = request3.headers();
org.jsoup.Connection connection14 = httpConnection0.data(strMap13);
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
java.util.Map<java.lang.String, java.lang.String> strMap17 = request15.headers();
request15.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser20 = request15.parser;
org.jsoup.Connection.Request request22 = request15.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap23 = request15.headers();
java.util.Map<java.lang.String, java.lang.String> strMap24 = request15.cookies();
org.jsoup.Connection connection25 = httpConnection0.data(strMap24);
org.jsoup.Connection connection27 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Response response28 = httpConnection0.res;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
}
@Test
public void test0737() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0737");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
boolean boolean6 = request0.ignoreContentType;
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "hi!");
java.lang.String str11 = request0.getHeaderCaseInsensitive("");
java.lang.String str13 = request0.cookie("");
request0.ignoreContentType = false;
java.util.Map<java.lang.String, java.lang.String> strMap16 = request0.cookies();
boolean boolean17 = request0.followRedirects();
org.jsoup.helper.HttpConnection.KeyVal keyVal18 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str19 = keyVal18.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal21 = keyVal18.value("hi!");
java.lang.String str22 = keyVal21.toString();
org.jsoup.helper.HttpConnection.Request request23 = request0.data((org.jsoup.Connection.KeyVal) keyVal21);
keyVal21.value = "hi!";
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str22 + "' != '" + "null=hi!" + "'", str22.equals("null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
}
@Test
public void test0738() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0738");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.Connection connection7 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection10 = httpConnection0.cookie("null=null", "null=null=null=hi!");
org.jsoup.Connection connection12 = httpConnection0.ignoreContentType(false);
org.jsoup.Connection connection15 = httpConnection0.cookie("hi!", "null=null=null=hi!=hi!");
java.net.URL uRL16 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection17 = httpConnection0.url(uRL16);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
}
@Test
public void test0739() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0739");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.helper.HttpConnection httpConnection6 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response7 = httpConnection6.response();
org.jsoup.Connection.Request request8 = httpConnection6.request();
org.jsoup.Connection connection10 = httpConnection6.ignoreContentType(true);
org.jsoup.Connection.Request request11 = httpConnection6.request();
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
org.jsoup.Connection.Method method15 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap16 = request12.cookies();
org.jsoup.Connection connection17 = httpConnection6.cookies(strMap16);
org.jsoup.helper.HttpConnection httpConnection18 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response19 = httpConnection18.response();
org.jsoup.Connection.Request request20 = httpConnection18.request();
org.jsoup.Connection connection22 = httpConnection18.ignoreContentType(true);
org.jsoup.Connection.Request request23 = httpConnection18.request();
org.jsoup.Connection connection25 = httpConnection18.referrer("null=hi!");
org.jsoup.helper.HttpConnection httpConnection26 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request27 = null;
org.jsoup.Connection connection28 = httpConnection26.request(request27);
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response30 = httpConnection29.response();
org.jsoup.Connection.Request request31 = httpConnection29.request();
org.jsoup.Connection connection32 = httpConnection26.request(request31);
org.jsoup.helper.HttpConnection httpConnection33 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection35 = httpConnection33.followRedirects(false);
org.jsoup.Connection connection37 = httpConnection33.referrer("");
org.jsoup.Connection.Response response38 = httpConnection33.response();
org.jsoup.Connection connection39 = httpConnection26.response(response38);
org.jsoup.Connection connection41 = httpConnection26.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request42 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method43 = request42.method();
boolean boolean44 = request42.ignoreHttpErrors();
org.jsoup.Connection.Request request47 = request42.cookie("hi!", "");
java.lang.String str49 = request42.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
boolean boolean52 = request50.followRedirects;
org.jsoup.Connection.Request request54 = request50.followRedirects(true);
java.lang.String str56 = request50.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request57 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method58 = request57.method();
org.jsoup.Connection.Request request59 = request50.method(method58);
org.jsoup.Connection.Request request60 = request42.method(method58);
org.jsoup.Connection connection61 = httpConnection26.method(method58);
org.jsoup.Connection connection63 = httpConnection26.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection64 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response65 = httpConnection64.response();
org.jsoup.Connection connection67 = httpConnection64.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection68 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response69 = httpConnection68.response();
httpConnection64.res = response69;
java.lang.String[] strArray73 = new java.lang.String[] { "null=null", "null=null" };
org.jsoup.Connection connection74 = httpConnection64.data(strArray73);
org.jsoup.Connection connection75 = httpConnection26.data(strArray73);
org.jsoup.Connection connection76 = httpConnection18.data(strArray73);
org.jsoup.Connection connection77 = httpConnection6.data(strArray73);
org.jsoup.Connection connection78 = httpConnection0.data(strArray73);
org.jsoup.helper.HttpConnection.Request request79 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method80 = request79.method();
boolean boolean81 = request79.ignoreHttpErrors();
org.jsoup.Connection.Request request84 = request79.cookie("hi!", "");
java.lang.String str86 = request79.cookie("null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap87 = request79.cookies();
int int88 = request79.maxBodySize();
java.util.Map<java.lang.String, java.lang.String> strMap89 = request79.headers();
org.jsoup.Connection connection90 = httpConnection0.cookies(strMap89);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
org.junit.Assert.assertTrue("'" + method15 + "' != '" + org.jsoup.Connection.Method.GET + "'", method15.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection41);
org.junit.Assert.assertTrue("'" + method43 + "' != '" + org.jsoup.Connection.Method.GET + "'", method43.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean44 + "' != '" + false + "'", boolean44 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str49);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + true + "'", boolean52 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str56);
org.junit.Assert.assertTrue("'" + method58 + "' != '" + org.jsoup.Connection.Method.GET + "'", method58.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response69);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray73);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection78);
org.junit.Assert.assertTrue("'" + method80 + "' != '" + org.jsoup.Connection.Method.GET + "'", method80.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean81 + "' != '" + false + "'", boolean81 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request84);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str86);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap87);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int88 + "' != '" + 1048576 + "'", int88 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap89);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection90);
}
@Test
public void test0740() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0740");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
org.jsoup.parser.Parser parser6 = null;
request0.parser = parser6;
org.jsoup.Connection.Request request9 = request0.followRedirects(true);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
}
@Test
public void test0741() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0741");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection3 = httpConnection0.data("hi!", "hi!");
org.jsoup.parser.Parser parser4 = null;
org.jsoup.Connection connection5 = httpConnection0.parser(parser4);
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
org.jsoup.Connection.Request request11 = request6.cookie("hi!", "");
boolean boolean12 = request6.ignoreContentType;
org.jsoup.Connection.Request request15 = request6.cookie("null=hi!", "hi!");
java.lang.String str17 = request6.getHeaderCaseInsensitive("");
java.lang.String str19 = request6.cookie("");
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
java.util.Map<java.lang.String, java.lang.String> strMap22 = request20.headers();
request20.followRedirects = false;
boolean boolean25 = request20.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request27 = request20.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry29 = request20.scanHeaders("null=null");
org.jsoup.Connection.Request request31 = request20.ignoreContentType(false);
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
boolean boolean34 = request32.ignoreHttpErrors();
org.jsoup.Connection.Request request37 = request32.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request38 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method39 = request38.method();
java.util.Map<java.lang.String, java.lang.String> strMap40 = request38.headers();
request38.followRedirects = false;
boolean boolean43 = request38.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request45 = request38.timeout((int) ' ');
java.lang.String str47 = request45.cookie("hi!");
java.lang.String str49 = request45.header("null=null");
request45.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request52 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method53 = request52.method();
java.util.Map<java.lang.String, java.lang.String> strMap54 = request52.headers();
request52.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser57 = request52.parser;
request45.parser = parser57;
org.jsoup.helper.HttpConnection.Request request59 = request32.parser(parser57);
org.jsoup.helper.HttpConnection.Request request60 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method61 = request60.method();
org.jsoup.Connection.Request request62 = request59.method(method61);
org.jsoup.Connection.Request request63 = request20.method(method61);
org.jsoup.Connection.Request request64 = request6.method(method61);
org.jsoup.Connection connection65 = httpConnection0.method(method61);
java.net.URL uRL66 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection67 = httpConnection0.url(uRL66);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request31);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + false + "'", boolean34 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request37);
org.junit.Assert.assertTrue("'" + method39 + "' != '" + org.jsoup.Connection.Method.GET + "'", method39.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + false + "'", boolean43 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str49);
org.junit.Assert.assertTrue("'" + method53 + "' != '" + org.jsoup.Connection.Method.GET + "'", method53.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request59);
org.junit.Assert.assertTrue("'" + method61 + "' != '" + org.jsoup.Connection.Method.GET + "'", method61.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection65);
}
@Test
public void test0742() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0742");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
int int15 = request0.timeout();
java.lang.String str16 = org.jsoup.helper.HttpConnection.Response.getRequestCookieString((org.jsoup.Connection.Request) request0);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 3000 + "'", int15 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str16 + "' != '" + "" + "'", str16.equals(""));
}
@Test
public void test0743() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0743");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request4 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
request5.followRedirects = false;
boolean boolean10 = request5.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request12 = request5.timeout((int) ' ');
java.lang.String str14 = request12.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request12.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
request17.timeoutMilliseconds = 307;
org.jsoup.parser.Parser parser25 = request17.parser();
org.jsoup.Connection connection26 = httpConnection0.parser(parser25);
org.jsoup.Connection connection28 = httpConnection0.userAgent("hi!=null");
org.jsoup.helper.HttpConnection.Request request29 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method30 = request29.method();
boolean boolean31 = request29.followRedirects;
org.jsoup.Connection.Request request33 = request29.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap34 = request29.cookies();
boolean boolean36 = request29.hasCookie("null=null");
boolean boolean38 = request29.hasHeader("null=hi!");
org.jsoup.Connection.Request request40 = request29.removeCookie("null=null");
org.jsoup.Connection.Request request42 = request29.ignoreContentType(false);
httpConnection0.req = request29;
java.lang.String str45 = request29.getHeaderCaseInsensitive("null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection28);
org.junit.Assert.assertTrue("'" + method30 + "' != '" + org.jsoup.Connection.Method.GET + "'", method30.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + true + "'", boolean31 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + false + "'", boolean36 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + false + "'", boolean38 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str45);
}
@Test
public void test0744() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0744");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
java.lang.String str15 = request13.cookie("hi!");
java.lang.String str17 = request13.header("null=null");
request13.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
java.util.Map<java.lang.String, java.lang.String> strMap22 = request20.headers();
request20.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser25 = request20.parser;
request13.parser = parser25;
org.jsoup.helper.HttpConnection.Request request27 = request0.parser(parser25);
boolean boolean28 = request0.ignoreHttpErrors();
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response30 = httpConnection29.response();
org.jsoup.Connection connection32 = httpConnection29.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection33 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection36 = httpConnection33.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
int int40 = request37.timeout();
org.jsoup.parser.Parser parser41 = request37.parser();
org.jsoup.Connection connection42 = httpConnection33.parser(parser41);
org.jsoup.Connection connection43 = httpConnection29.parser(parser41);
org.jsoup.helper.HttpConnection.Request request44 = request0.parser(parser41);
int int45 = request44.maxBodySizeBytes;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 3000 + "'", int40 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 1048576 + "'", int45 == 1048576);
}
@Test
public void test0745() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0745");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
org.jsoup.Connection.Response response9 = response1.removeCookie("");
java.lang.String str10 = response1.statusMessage();
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document11 = response1.parse();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before parsing response");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
}
@Test
public void test0746() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0746");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
boolean boolean4 = request0.hasCookie("null=null");
int int5 = request0.timeoutMilliseconds;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 3000 + "'", int5 == 3000);
}
@Test
public void test0747() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0747");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
request7.followRedirects = false;
boolean boolean12 = request7.ignoreHttpErrors;
org.jsoup.Connection.Method method13 = request7.method();
org.jsoup.helper.HttpConnection.Request request14 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method15 = request14.method();
boolean boolean16 = request14.followRedirects;
org.jsoup.Connection.Request request18 = request14.followRedirects(true);
java.lang.String str20 = request14.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request21 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method22 = request21.method();
org.jsoup.Connection.Request request23 = request14.method(method22);
org.jsoup.Connection.Request request24 = request7.method(method22);
org.jsoup.Connection.Request request25 = request0.method(method22);
boolean boolean26 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request29 = request0.header("null=", "null=null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method15 + "' != '" + org.jsoup.Connection.Method.GET + "'", method15.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + true + "'", boolean16 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
org.junit.Assert.assertTrue("'" + method22 + "' != '" + org.jsoup.Connection.Method.GET + "'", method22.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + false + "'", boolean26 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
}
@Test
public void test0748() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0748");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = keyVal13.value("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal22 = keyVal13.value("null=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal22);
}
@Test
public void test0749() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0749");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.helper.HttpConnection.Request request14 = request0.timeout(0);
boolean boolean16 = request14.hasHeader("null=null");
java.net.URL uRL17 = request14.url();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL17);
}
@Test
public void test0750() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0750");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal2.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal2.value("null=null");
java.lang.String str7 = keyVal2.value();
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal2.value("null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str7 + "' != '" + "null=null" + "'", str7.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
}
@Test
public void test0751() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0751");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = request0.scanHeaders("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection10 = request0.data;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection11 = request0.data();
java.util.Map<java.lang.String, java.lang.String> strMap12 = request0.cookies();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
}
@Test
public void test0752() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0752");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
boolean boolean18 = request16.followRedirects;
org.jsoup.Connection.Request request20 = request16.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap21 = request16.cookies();
org.jsoup.Connection connection22 = httpConnection0.cookies(strMap21);
org.jsoup.helper.HttpConnection.Request request23 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method24 = request23.method();
java.util.Map<java.lang.String, java.lang.String> strMap25 = request23.headers();
request23.followRedirects = false;
boolean boolean28 = request23.ignoreHttpErrors;
org.jsoup.Connection.Method method29 = request23.method();
int int30 = request23.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
boolean boolean33 = request31.followRedirects;
org.jsoup.Connection.Request request35 = request31.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap36 = request31.headers();
boolean boolean37 = request31.ignoreContentType;
boolean boolean38 = request31.followRedirects();
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request31.method(method40);
org.jsoup.Connection.Request request42 = request23.method(method40);
org.jsoup.Connection connection43 = httpConnection0.method(method40);
org.jsoup.Connection connection46 = httpConnection0.cookie("null=hi!", "");
org.jsoup.Connection connection48 = httpConnection0.ignoreHttpErrors(true);
org.jsoup.Connection.Response response49 = httpConnection0.response();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + true + "'", boolean18 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
org.junit.Assert.assertTrue("'" + method24 + "' != '" + org.jsoup.Connection.Method.GET + "'", method24.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 1048576 + "'", int30 == 1048576);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + true + "'", boolean33 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + true + "'", boolean38 == true);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response49);
}
@Test
public void test0753() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0753");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.parser.Parser parser7 = null;
org.jsoup.Connection connection8 = httpConnection0.parser(parser7);
org.jsoup.helper.HttpConnection httpConnection9 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection11 = httpConnection9.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean17 = request12.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request19 = request12.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry21 = request12.scanHeaders("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap22 = request12.headers();
org.jsoup.Connection connection23 = httpConnection9.data(strMap22);
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
java.util.Map<java.lang.String, java.lang.String> strMap26 = request24.headers();
request24.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser29 = request24.parser;
org.jsoup.Connection.Request request31 = request24.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap32 = request24.headers();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request24.cookies();
org.jsoup.Connection connection34 = httpConnection9.data(strMap33);
org.jsoup.helper.HttpConnection httpConnection35 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response36 = httpConnection35.response();
org.jsoup.Connection.Request request37 = httpConnection35.request();
org.jsoup.Connection connection39 = httpConnection35.ignoreContentType(true);
org.jsoup.Connection.Request request40 = httpConnection35.request();
org.jsoup.Connection connection42 = httpConnection35.referrer("null=hi!");
org.jsoup.helper.HttpConnection httpConnection43 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request44 = null;
org.jsoup.Connection connection45 = httpConnection43.request(request44);
org.jsoup.helper.HttpConnection httpConnection46 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response47 = httpConnection46.response();
org.jsoup.Connection.Request request48 = httpConnection46.request();
org.jsoup.Connection connection49 = httpConnection43.request(request48);
org.jsoup.helper.HttpConnection httpConnection50 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection52 = httpConnection50.followRedirects(false);
org.jsoup.Connection connection54 = httpConnection50.referrer("");
org.jsoup.Connection.Response response55 = httpConnection50.response();
org.jsoup.Connection connection56 = httpConnection43.response(response55);
org.jsoup.Connection connection58 = httpConnection43.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request59 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method60 = request59.method();
boolean boolean61 = request59.ignoreHttpErrors();
org.jsoup.Connection.Request request64 = request59.cookie("hi!", "");
java.lang.String str66 = request59.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request67 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method68 = request67.method();
boolean boolean69 = request67.followRedirects;
org.jsoup.Connection.Request request71 = request67.followRedirects(true);
java.lang.String str73 = request67.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request74 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method75 = request74.method();
org.jsoup.Connection.Request request76 = request67.method(method75);
org.jsoup.Connection.Request request77 = request59.method(method75);
org.jsoup.Connection connection78 = httpConnection43.method(method75);
org.jsoup.Connection connection80 = httpConnection43.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection81 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response82 = httpConnection81.response();
org.jsoup.Connection connection84 = httpConnection81.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection85 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response86 = httpConnection85.response();
httpConnection81.res = response86;
java.lang.String[] strArray90 = new java.lang.String[] { "null=null", "null=null" };
org.jsoup.Connection connection91 = httpConnection81.data(strArray90);
org.jsoup.Connection connection92 = httpConnection43.data(strArray90);
org.jsoup.Connection connection93 = httpConnection35.data(strArray90);
org.jsoup.Connection connection94 = httpConnection9.data(strArray90);
org.jsoup.Connection connection95 = httpConnection0.data(strArray90);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response96 = httpConnection0.execute();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection58);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean61 + "' != '" + false + "'", boolean61 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str66);
org.junit.Assert.assertTrue("'" + method68 + "' != '" + org.jsoup.Connection.Method.GET + "'", method68.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean69 + "' != '" + true + "'", boolean69 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str73);
org.junit.Assert.assertTrue("'" + method75 + "' != '" + org.jsoup.Connection.Method.GET + "'", method75.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection78);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response82);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection84);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response86);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray90);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection91);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection92);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection93);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection94);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection95);
}
@Test
public void test0754() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0754");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
request7.followRedirects = false;
boolean boolean12 = request7.ignoreHttpErrors;
org.jsoup.Connection.Method method13 = request7.method();
org.jsoup.Connection connection14 = httpConnection0.method(method13);
org.jsoup.Connection connection16 = httpConnection0.maxBodySize(3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
}
@Test
public void test0755() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0755");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request0.headers();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
}
@Test
public void test0756() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0756");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
int int19 = request18.timeout();
java.util.Map<java.lang.String, java.lang.String> strMap20 = request18.cookies();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry22 = request18.scanHeaders("");
boolean boolean23 = request18.followRedirects();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 3000 + "'", int19 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + true + "'", boolean23 == true);
}
@Test
public void test0757() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0757");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.helper.HttpConnection.Request request14 = request0.timeout(0);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request0.data();
org.jsoup.Connection.Request request18 = request0.cookie("null=null=null=hi!", "null=null=null=hi!");
org.jsoup.Connection.Request request21 = request0.header("hi!", "null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
}
@Test
public void test0758() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0758");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
java.lang.String str9 = request0.cookie("hi!=null");
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
boolean boolean22 = request17.ignoreHttpErrors;
org.jsoup.Connection.Method method23 = request17.method();
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
boolean boolean26 = request24.followRedirects;
org.jsoup.Connection.Request request28 = request24.followRedirects(true);
java.lang.String str30 = request24.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
org.jsoup.Connection.Request request33 = request24.method(method32);
org.jsoup.Connection.Request request34 = request17.method(method32);
org.jsoup.Connection.Request request35 = request10.method(method32);
org.jsoup.Connection.Request request36 = request0.method(method32);
org.jsoup.Connection.Request request38 = request0.ignoreContentType(true);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + true + "'", boolean26 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str30);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
}
@Test
public void test0759() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0759");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.net.URL uRL4 = response1.url();
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
org.jsoup.helper.HttpConnection.Request request9 = request5.timeout(1048576);
java.lang.String str11 = request5.getHeaderCaseInsensitive("hi!=null");
response1.req = request5;
response1.contentType = "hi!=";
boolean boolean15 = response1.executed;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
}
@Test
public void test0760() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0760");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
response1.executed = true;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
}
@Test
public void test0761() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0761");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
java.lang.String str6 = request0.cookie("");
org.jsoup.Connection.Request request8 = request0.maxBodySize((int) (short) 100);
boolean boolean9 = request0.ignoreHttpErrors;
request0.followRedirects = false;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
}
@Test
public void test0762() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0762");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap8 = request0.headers();
java.net.URL uRL9 = request0.url();
boolean boolean10 = request0.ignoreHttpErrors();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
}
@Test
public void test0763() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0763");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.helper.HttpConnection.Request request14 = request0.timeout(0);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry16 = request0.scanHeaders("null=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry16);
}
@Test
public void test0764() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0764");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str5 = response1.statusMessage();
java.lang.String str7 = response1.header("hi!=null=hi!=null");
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection11 = httpConnection8.data("hi!", "hi!");
org.jsoup.parser.Parser parser12 = null;
org.jsoup.Connection connection13 = httpConnection8.parser(parser12);
org.jsoup.helper.HttpConnection httpConnection14 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response15 = httpConnection14.response();
org.jsoup.Connection.Request request16 = httpConnection14.request();
org.jsoup.Connection.Request request17 = httpConnection14.req;
org.jsoup.Connection connection19 = httpConnection14.timeout((int) 'a');
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
boolean boolean22 = request20.ignoreHttpErrors();
org.jsoup.Connection.Request request25 = request20.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.followRedirects = false;
boolean boolean31 = request26.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request33 = request26.timeout((int) ' ');
java.lang.String str35 = request33.cookie("hi!");
java.lang.String str37 = request33.header("null=null");
request33.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request40 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method41 = request40.method();
java.util.Map<java.lang.String, java.lang.String> strMap42 = request40.headers();
request40.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser45 = request40.parser;
request33.parser = parser45;
org.jsoup.helper.HttpConnection.Request request47 = request20.parser(parser45);
org.jsoup.Connection connection48 = httpConnection14.request((org.jsoup.Connection.Request) request47);
org.jsoup.helper.HttpConnection.Request request49 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method50 = request49.method();
boolean boolean51 = request49.followRedirects;
org.jsoup.Connection.Request request53 = request49.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap54 = request49.headers();
boolean boolean55 = request49.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request56 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method57 = request56.method();
java.util.Map<java.lang.String, java.lang.String> strMap58 = request56.headers();
request56.followRedirects = false;
boolean boolean61 = request56.ignoreHttpErrors;
org.jsoup.Connection.Method method62 = request56.method();
org.jsoup.helper.HttpConnection.Request request63 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method64 = request63.method();
boolean boolean65 = request63.followRedirects;
org.jsoup.Connection.Request request67 = request63.followRedirects(true);
java.lang.String str69 = request63.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request70 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method71 = request70.method();
org.jsoup.Connection.Request request72 = request63.method(method71);
org.jsoup.Connection.Request request73 = request56.method(method71);
org.jsoup.Connection.Request request74 = request49.method(method71);
org.jsoup.Connection connection75 = httpConnection14.method(method71);
org.jsoup.Connection connection76 = httpConnection8.method(method71);
org.jsoup.Connection.Response response77 = response1.method(method71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
org.junit.Assert.assertTrue("'" + method41 + "' != '" + org.jsoup.Connection.Method.GET + "'", method41.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
org.junit.Assert.assertTrue("'" + method50 + "' != '" + org.jsoup.Connection.Method.GET + "'", method50.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean51 + "' != '" + true + "'", boolean51 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean55 + "' != '" + false + "'", boolean55 == false);
org.junit.Assert.assertTrue("'" + method57 + "' != '" + org.jsoup.Connection.Method.GET + "'", method57.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean61 + "' != '" + false + "'", boolean61 == false);
org.junit.Assert.assertTrue("'" + method62 + "' != '" + org.jsoup.Connection.Method.GET + "'", method62.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method64 + "' != '" + org.jsoup.Connection.Method.GET + "'", method64.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean65 + "' != '" + true + "'", boolean65 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str69);
org.junit.Assert.assertTrue("'" + method71 + "' != '" + org.jsoup.Connection.Method.GET + "'", method71.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request73);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response77);
}
@Test
public void test0765() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0765");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
org.jsoup.Connection.Request request11 = request6.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean17 = request12.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request19 = request12.timeout((int) ' ');
java.lang.String str21 = request19.cookie("hi!");
java.lang.String str23 = request19.header("null=null");
request19.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser31 = request26.parser;
request19.parser = parser31;
org.jsoup.helper.HttpConnection.Request request33 = request6.parser(parser31);
org.jsoup.Connection connection34 = httpConnection0.request((org.jsoup.Connection.Request) request33);
org.jsoup.Connection connection36 = httpConnection0.userAgent("");
org.jsoup.helper.HttpConnection.Response response37 = null;
org.jsoup.helper.HttpConnection.Response response38 = new org.jsoup.helper.HttpConnection.Response(response37);
int int39 = response38.numRedirects;
response38.charset = "hi!=null";
org.jsoup.Connection.Response response43 = response38.removeCookie("null=null");
org.jsoup.Connection connection44 = httpConnection0.response(response43);
org.jsoup.helper.HttpConnection.Request request45 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method46 = request45.method();
org.jsoup.helper.HttpConnection.Request request47 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method48 = request47.method();
boolean boolean49 = request47.followRedirects;
org.jsoup.Connection.Request request51 = request47.followRedirects(true);
java.lang.String str53 = request47.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request54 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method55 = request54.method();
org.jsoup.Connection.Request request56 = request47.method(method55);
org.jsoup.Connection.Request request57 = request45.method(method55);
org.jsoup.helper.HttpConnection.KeyVal keyVal58 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str59 = keyVal58.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal61 = keyVal58.value("");
java.lang.String str62 = keyVal58.value();
org.jsoup.helper.HttpConnection.Request request63 = request45.data((org.jsoup.Connection.KeyVal) keyVal58);
org.jsoup.Connection.Request request66 = request45.cookie("null=hi!", "null=null=null=hi!");
org.jsoup.Connection connection67 = httpConnection0.request(request66);
org.jsoup.Connection connection70 = httpConnection0.header("hi!", "hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 0 + "'", int39 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection44);
org.junit.Assert.assertTrue("'" + method46 + "' != '" + org.jsoup.Connection.Method.GET + "'", method46.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method48 + "' != '" + org.jsoup.Connection.Method.GET + "'", method48.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean49 + "' != '" + true + "'", boolean49 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str53);
org.junit.Assert.assertTrue("'" + method55 + "' != '" + org.jsoup.Connection.Method.GET + "'", method55.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str59 + "' != '" + "null=null" + "'", str59.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str62 + "' != '" + "" + "'", str62.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request66);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection70);
}
@Test
public void test0766() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0766");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
java.lang.String str7 = response1.statusMessage;
response1.contentType = "null=null=hi!";
java.nio.ByteBuffer byteBuffer10 = response1.byteData;
int int11 = response1.statusCode();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(byteBuffer10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 0 + "'", int11 == 0);
}
@Test
public void test0767() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0767");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.parser.Parser parser7 = null;
org.jsoup.Connection connection8 = httpConnection0.parser(parser7);
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
java.util.Map<java.lang.String, java.lang.String> strMap11 = request9.headers();
request9.followRedirects = false;
boolean boolean14 = request9.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request9.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
request17.timeoutMilliseconds = 307;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.followRedirects = false;
boolean boolean30 = request25.ignoreHttpErrors;
org.jsoup.Connection.Method method31 = request25.method();
int int32 = request25.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
boolean boolean35 = request33.followRedirects;
org.jsoup.Connection.Request request37 = request33.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap38 = request33.headers();
boolean boolean39 = request33.ignoreContentType;
boolean boolean40 = request33.followRedirects();
org.jsoup.helper.HttpConnection.Request request41 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method42 = request41.method();
org.jsoup.Connection.Request request43 = request33.method(method42);
org.jsoup.Connection.Request request44 = request25.method(method42);
org.jsoup.Connection.Request request45 = request17.method(method42);
org.jsoup.Connection connection46 = httpConnection0.method(method42);
org.jsoup.Connection.Response response47 = httpConnection0.response();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean30 + "' != '" + false + "'", boolean30 == false);
org.junit.Assert.assertTrue("'" + method31 + "' != '" + org.jsoup.Connection.Method.GET + "'", method31.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int32 + "' != '" + 1048576 + "'", int32 == 1048576);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean35 + "' != '" + true + "'", boolean35 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean39 + "' != '" + false + "'", boolean39 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean40 + "' != '" + true + "'", boolean40 == true);
org.junit.Assert.assertTrue("'" + method42 + "' != '" + org.jsoup.Connection.Method.GET + "'", method42.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response47);
}
@Test
public void test0768() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0768");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = response1.scanHeaders("hi!=");
int int18 = response1.numRedirects;
java.lang.String str19 = response1.statusMessage;
java.net.URL uRL20 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response21 = response1.url(uRL20);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
}
@Test
public void test0769() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0769");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection5 = httpConnection0.ignoreHttpErrors(true);
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
boolean boolean14 = request13.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal17 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal17.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal23 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal25 = keyVal23.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal26 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal26.key = "hi!";
java.lang.String str29 = keyVal26.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal31 = keyVal26.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal34 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal35.key = "hi!";
java.lang.String str38 = keyVal35.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str40 = keyVal39.toString();
keyVal39.value = "";
keyVal39.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal45.key = "hi!";
java.lang.String str48 = keyVal45.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal50 = keyVal45.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal51 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str52 = keyVal51.key();
org.jsoup.Connection.KeyVal[] keyValArray53 = new org.jsoup.Connection.KeyVal[] { keyVal17, keyVal20, keyVal25, keyVal26, keyVal34, keyVal35, keyVal39, keyVal45, keyVal51 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList54 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean55 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54, keyValArray53);
request13.data = keyValList54;
org.jsoup.Connection connection57 = httpConnection0.data((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54);
org.jsoup.Connection.Response response58 = httpConnection0.response();
org.jsoup.Connection connection60 = httpConnection0.followRedirects(true);
org.jsoup.Connection connection62 = httpConnection0.maxBodySize((int) '4');
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str29 + "' != '" + "hi!" + "'", str29.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str38 + "' != '" + "hi!" + "'", str38.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str40 + "' != '" + "null=null" + "'", str40.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str48 + "' != '" + "hi!" + "'", str48.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean55 + "' != '" + true + "'", boolean55 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection62);
}
@Test
public void test0770() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0770");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
int int3 = request0.timeout();
boolean boolean4 = request0.ignoreHttpErrors();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = org.jsoup.helper.HttpConnection.KeyVal.create("null=null=null=hi!", "null=null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal7.key("hi!=");
keyVal7.value = "";
org.jsoup.helper.HttpConnection.Request request12 = request0.data((org.jsoup.Connection.KeyVal) keyVal7);
request12.ignoreContentType = true;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3000 + "'", int3 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
}
@Test
public void test0771() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0771");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection9 = httpConnection7.followRedirects(false);
org.jsoup.Connection connection11 = httpConnection7.referrer("");
org.jsoup.Connection.Response response12 = httpConnection7.response();
org.jsoup.Connection connection13 = httpConnection0.response(response12);
org.jsoup.Connection connection15 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection17 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Request request18 = null;
org.jsoup.Connection connection19 = httpConnection0.request(request18);
org.jsoup.Connection.Request request20 = httpConnection0.req;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request20);
}
@Test
public void test0772() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0772");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
org.jsoup.Connection connection11 = httpConnection8.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request12 = httpConnection8.req;
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
java.util.Map<java.lang.String, java.lang.String> strMap15 = request13.headers();
request13.followRedirects = false;
boolean boolean18 = request13.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request20 = request13.timeout((int) ' ');
java.lang.String str22 = request20.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection23 = request20.data();
org.jsoup.Connection connection24 = httpConnection8.data(keyValCollection23);
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
boolean boolean27 = request25.followRedirects;
org.jsoup.Connection.Request request29 = request25.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap30 = request25.headers();
boolean boolean31 = request25.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
java.util.Map<java.lang.String, java.lang.String> strMap34 = request32.headers();
request32.followRedirects = false;
boolean boolean37 = request32.ignoreHttpErrors;
org.jsoup.Connection.Method method38 = request32.method();
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
boolean boolean41 = request39.followRedirects;
org.jsoup.Connection.Request request43 = request39.followRedirects(true);
java.lang.String str45 = request39.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request46 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method47 = request46.method();
org.jsoup.Connection.Request request48 = request39.method(method47);
org.jsoup.Connection.Request request49 = request32.method(method47);
org.jsoup.Connection.Request request50 = request25.method(method47);
org.jsoup.Connection connection51 = httpConnection8.method(method47);
org.jsoup.Connection.Request request52 = request0.method(method47);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request55 = request0.header("", "");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + false + "'", boolean18 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + true + "'", boolean27 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean41 + "' != '" + true + "'", boolean41 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str45);
org.junit.Assert.assertTrue("'" + method47 + "' != '" + org.jsoup.Connection.Method.GET + "'", method47.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
}
@Test
public void test0773() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0773");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.helper.HttpConnection.Request request14 = request0.timeout(0);
org.jsoup.Connection.Method method15 = request0.method();
org.jsoup.Connection.Request request17 = request0.ignoreContentType(true);
org.jsoup.parser.Parser parser18 = request0.parser;
org.jsoup.Connection.Request request20 = request0.removeCookie("null=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
org.junit.Assert.assertTrue("'" + method15 + "' != '" + org.jsoup.Connection.Method.GET + "'", method15.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
}
@Test
public void test0774() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0774");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
response1.statusMessage = "hi!=";
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document4 = response1.parse();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before parsing response");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
}
@Test
public void test0775() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0775");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
org.jsoup.helper.HttpConnection.Request request4 = request0.timeout(1048576);
boolean boolean5 = request0.ignoreContentType;
request0.timeoutMilliseconds = (byte) -1;
org.jsoup.Connection.Request request10 = request0.cookie("null=null=null=hi!", "");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
}
@Test
public void test0776() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0776");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.util.Map<java.lang.String, java.lang.String> strMap8 = request7.cookies();
boolean boolean10 = request7.hasHeader("null=null");
org.jsoup.Connection.Request request12 = request7.ignoreHttpErrors(false);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
}
@Test
public void test0777() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0777");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.headers();
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str5 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = keyVal4.value("hi!");
java.lang.String str8 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal4.value("hi!");
java.lang.String str11 = keyVal4.key();
org.jsoup.helper.HttpConnection.Request request12 = request0.data((org.jsoup.Connection.KeyVal) keyVal4);
java.lang.String str13 = keyVal4.key();
java.lang.String str14 = keyVal4.toString();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=hi!" + "'", str14.equals("null=hi!"));
}
@Test
public void test0778() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0778");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
boolean boolean6 = request0.ignoreContentType;
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "hi!");
java.lang.String str11 = request0.getHeaderCaseInsensitive("");
java.lang.String str13 = request0.cookie("");
org.jsoup.helper.HttpConnection.Request request14 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method15 = request14.method();
java.util.Map<java.lang.String, java.lang.String> strMap16 = request14.headers();
request14.followRedirects = false;
boolean boolean19 = request14.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request21 = request14.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry23 = request14.scanHeaders("null=null");
org.jsoup.Connection.Request request25 = request14.ignoreContentType(false);
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
boolean boolean28 = request26.ignoreHttpErrors();
org.jsoup.Connection.Request request31 = request26.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
java.util.Map<java.lang.String, java.lang.String> strMap34 = request32.headers();
request32.followRedirects = false;
boolean boolean37 = request32.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request39 = request32.timeout((int) ' ');
java.lang.String str41 = request39.cookie("hi!");
java.lang.String str43 = request39.header("null=null");
request39.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request46 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method47 = request46.method();
java.util.Map<java.lang.String, java.lang.String> strMap48 = request46.headers();
request46.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser51 = request46.parser;
request39.parser = parser51;
org.jsoup.helper.HttpConnection.Request request53 = request26.parser(parser51);
org.jsoup.helper.HttpConnection.Request request54 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method55 = request54.method();
org.jsoup.Connection.Request request56 = request53.method(method55);
org.jsoup.Connection.Request request57 = request14.method(method55);
org.jsoup.Connection.Request request58 = request0.method(method55);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection59 = request0.data();
org.jsoup.Connection.Method method60 = request0.method();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str13);
org.junit.Assert.assertTrue("'" + method15 + "' != '" + org.jsoup.Connection.Method.GET + "'", method15.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + false + "'", boolean19 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request31);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str43);
org.junit.Assert.assertTrue("'" + method47 + "' != '" + org.jsoup.Connection.Method.GET + "'", method47.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
org.junit.Assert.assertTrue("'" + method55 + "' != '" + org.jsoup.Connection.Method.GET + "'", method55.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection59);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
}
@Test
public void test0779() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0779");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal0.value("hi!");
java.lang.String str7 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal0.value("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal11 = keyVal0.value("");
keyVal0.value = "null=null=";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal11);
}
@Test
public void test0780() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0780");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection connection4 = httpConnection0.ignoreContentType(true);
org.jsoup.Connection.Request request5 = httpConnection0.request();
org.jsoup.Connection connection7 = httpConnection0.referrer("null=hi!");
java.net.URL uRL8 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection9 = httpConnection0.url(uRL8);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
}
@Test
public void test0781() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0781");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal3.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal3.key("null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
}
@Test
public void test0782() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0782");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry7 = response1.scanHeaders("null=hi!");
java.lang.String str9 = response1.header("hi!");
java.net.URL uRL10 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response11 = response1.url(uRL10);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
}
@Test
public void test0783() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0783");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.helper.HttpConnection.Response response7 = null;
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response7);
java.lang.String str9 = response8.contentType();
java.lang.String str10 = response8.contentType();
int int11 = response8.statusCode();
httpConnection0.res = response8;
// The following exception was thrown during execution in test generation
try {
byte[] byteArray13 = response8.bodyAsBytes();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before getting response body");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 0 + "'", int11 == 0);
}
@Test
public void test0784() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0784");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
org.jsoup.parser.Parser parser9 = request7.parser;
java.lang.String str11 = request7.getHeaderCaseInsensitive("");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
}
@Test
public void test0785() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0785");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.helper.HttpConnection.Request request4 = request0.timeout((int) (short) 0);
org.jsoup.Connection.Method method5 = request0.method();
boolean boolean6 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request8 = request0.timeout((int) (byte) 100);
java.lang.String str10 = request0.cookie("hi!=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method5 + "' != '" + org.jsoup.Connection.Method.GET + "'", method5.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
}
@Test
public void test0786() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0786");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.helper.HttpConnection.Request request14 = request0.timeout(0);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request0.data();
org.jsoup.Connection.Request request18 = request0.cookie("null=null=null=hi!", "null=null=null=hi!");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request21 = request0.header("", "null=null=");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
}
@Test
public void test0787() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0787");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
java.lang.String str14 = request0.cookie("null=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
}
@Test
public void test0788() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0788");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
org.jsoup.Connection.Request request11 = request6.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean17 = request12.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request19 = request12.timeout((int) ' ');
java.lang.String str21 = request19.cookie("hi!");
java.lang.String str23 = request19.header("null=null");
request19.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser31 = request26.parser;
request19.parser = parser31;
org.jsoup.helper.HttpConnection.Request request33 = request6.parser(parser31);
org.jsoup.Connection connection34 = httpConnection0.request((org.jsoup.Connection.Request) request33);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection35 = request33.data;
java.util.Map<java.lang.String, java.lang.String> strMap36 = request33.headers();
java.util.Map<java.lang.String, java.lang.String> strMap37 = request33.cookies();
int int38 = request33.timeout();
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
boolean boolean41 = request39.followRedirects;
org.jsoup.Connection.Request request43 = request39.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap44 = request39.headers();
boolean boolean45 = request39.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request46 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method47 = request46.method();
java.util.Map<java.lang.String, java.lang.String> strMap48 = request46.headers();
request46.followRedirects = false;
boolean boolean51 = request46.ignoreHttpErrors;
org.jsoup.Connection.Method method52 = request46.method();
org.jsoup.helper.HttpConnection.Request request53 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method54 = request53.method();
boolean boolean55 = request53.followRedirects;
org.jsoup.Connection.Request request57 = request53.followRedirects(true);
java.lang.String str59 = request53.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request60 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method61 = request60.method();
org.jsoup.Connection.Request request62 = request53.method(method61);
org.jsoup.Connection.Request request63 = request46.method(method61);
org.jsoup.Connection.Request request64 = request39.method(method61);
org.jsoup.Connection.Request request65 = request33.method(method61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int38 + "' != '" + 3000 + "'", int38 == 3000);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean41 + "' != '" + true + "'", boolean41 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + false + "'", boolean45 == false);
org.junit.Assert.assertTrue("'" + method47 + "' != '" + org.jsoup.Connection.Method.GET + "'", method47.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean51 + "' != '" + false + "'", boolean51 == false);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method54 + "' != '" + org.jsoup.Connection.Method.GET + "'", method54.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean55 + "' != '" + true + "'", boolean55 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str59);
org.junit.Assert.assertTrue("'" + method61 + "' != '" + org.jsoup.Connection.Method.GET + "'", method61.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request65);
}
@Test
public void test0789() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0789");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
org.jsoup.helper.HttpConnection.Response response5 = new org.jsoup.helper.HttpConnection.Response(response1);
java.lang.String str7 = response1.header("null=hi!");
org.jsoup.Connection.Request request8 = response1.req;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request8);
}
@Test
public void test0790() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0790");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
java.util.Map<java.lang.String, java.lang.String> strMap4 = request2.headers();
request2.followRedirects = false;
boolean boolean7 = request2.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request9 = request2.timeout((int) ' ');
boolean boolean10 = request9.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal13.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal19 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal21 = keyVal19.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal22 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal22.key = "hi!";
java.lang.String str25 = keyVal22.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal27 = keyVal22.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal30 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal31 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal31.key = "hi!";
java.lang.String str34 = keyVal31.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str36 = keyVal35.toString();
keyVal35.value = "";
keyVal35.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal41 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal41.key = "hi!";
java.lang.String str44 = keyVal41.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal46 = keyVal41.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal47 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str48 = keyVal47.key();
org.jsoup.Connection.KeyVal[] keyValArray49 = new org.jsoup.Connection.KeyVal[] { keyVal13, keyVal16, keyVal21, keyVal22, keyVal30, keyVal31, keyVal35, keyVal41, keyVal47 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList50 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean51 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList50, keyValArray49);
request9.data = keyValList50;
org.jsoup.helper.HttpConnection.Request request53 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method54 = request53.method();
java.util.Map<java.lang.String, java.lang.String> strMap55 = request53.headers();
request53.followRedirects = false;
java.lang.String str59 = request53.cookie("");
boolean boolean60 = request53.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request61 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method62 = request61.method();
java.util.Map<java.lang.String, java.lang.String> strMap63 = request61.headers();
request61.followRedirects = false;
boolean boolean66 = request61.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection67 = request61.data();
request53.data = keyValCollection67;
request9.data = keyValCollection67;
org.jsoup.Connection connection70 = httpConnection0.data(keyValCollection67);
org.jsoup.helper.HttpConnection httpConnection71 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response72 = httpConnection71.response();
org.jsoup.Connection connection74 = httpConnection71.maxBodySize((int) (short) 0);
org.jsoup.helper.HttpConnection httpConnection75 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response76 = httpConnection75.response();
httpConnection71.res = response76;
org.jsoup.Connection connection80 = httpConnection71.header("hi!", "");
java.lang.String[] strArray87 = new java.lang.String[] { "null=null=null=hi!", "null=null=null=hi!", "null=null", "null=hi!", "null=null", "null=null" };
org.jsoup.Connection connection88 = httpConnection71.data(strArray87);
org.jsoup.Connection connection89 = httpConnection0.data(strArray87);
org.jsoup.Connection connection91 = httpConnection0.ignoreContentType(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str25 + "' != '" + "hi!" + "'", str25.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str34 + "' != '" + "hi!" + "'", str34.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str36 + "' != '" + "null=null" + "'", str36.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str44 + "' != '" + "hi!" + "'", str44.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean51 + "' != '" + true + "'", boolean51 == true);
org.junit.Assert.assertTrue("'" + method54 + "' != '" + org.jsoup.Connection.Method.GET + "'", method54.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean60 + "' != '" + false + "'", boolean60 == false);
org.junit.Assert.assertTrue("'" + method62 + "' != '" + org.jsoup.Connection.Method.GET + "'", method62.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean66 + "' != '" + false + "'", boolean66 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection70);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray87);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection88);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection89);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection91);
}
@Test
public void test0791() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0791");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry13 = request7.scanHeaders("");
java.net.URL uRL14 = request7.url();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL14);
}
@Test
public void test0792() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0792");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str7 = response1.cookie("null=null");
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response1);
java.lang.String str10 = response8.header("hi!");
boolean boolean11 = response8.executed;
java.net.HttpURLConnection httpURLConnection12 = null;
org.jsoup.helper.HttpConnection.Response response13 = null;
org.jsoup.helper.HttpConnection.Response response14 = new org.jsoup.helper.HttpConnection.Response(response13);
int int15 = response14.statusCode();
int int16 = response14.numRedirects;
java.lang.String str17 = response14.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry19 = response14.scanHeaders("");
response14.charset = "null=null";
// The following exception was thrown during execution in test generation
try {
response8.setupFromConnection(httpURLConnection12, (org.jsoup.Connection.Response) response14);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 0 + "'", int16 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry19);
}
@Test
public void test0793() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0793");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
org.jsoup.Connection connection7 = httpConnection4.maxBodySize((int) (short) 0);
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
httpConnection4.res = response9;
httpConnection0.res = response9;
org.jsoup.Connection connection14 = httpConnection0.header("hi!", "");
org.jsoup.Connection.Request request15 = httpConnection0.req;
org.jsoup.Connection connection17 = httpConnection0.referrer("null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
}
@Test
public void test0794() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0794");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection3 = httpConnection0.data("hi!", "hi!");
org.jsoup.parser.Parser parser4 = null;
org.jsoup.Connection connection5 = httpConnection0.parser(parser4);
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document6 = httpConnection0.post();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
}
@Test
public void test0795() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0795");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection19 = httpConnection0.referrer("hi!");
org.jsoup.helper.HttpConnection httpConnection20 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response21 = httpConnection20.response();
org.jsoup.Connection connection23 = httpConnection20.followRedirects(false);
org.jsoup.Connection.Response response24 = httpConnection20.response();
httpConnection0.res = response24;
org.jsoup.Connection connection27 = httpConnection0.ignoreHttpErrors(true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection27);
}
@Test
public void test0796() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0796");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection.Request request7 = httpConnection0.req;
org.jsoup.Connection connection9 = httpConnection0.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
request10.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap19 = request10.cookies();
httpConnection0.req = request10;
org.jsoup.helper.HttpConnection httpConnection21 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection23 = httpConnection21.followRedirects(false);
org.jsoup.Connection connection25 = httpConnection21.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection26 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response27 = httpConnection26.response();
org.jsoup.helper.HttpConnection httpConnection28 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response29 = httpConnection28.response();
org.jsoup.Connection connection31 = httpConnection28.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection32 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response33 = httpConnection32.response();
httpConnection28.res = response33;
httpConnection26.res = response33;
org.jsoup.Connection connection36 = httpConnection21.response(response33);
httpConnection0.res = response33;
org.jsoup.helper.HttpConnection.Request request38 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method39 = request38.method();
boolean boolean40 = request38.followRedirects;
org.jsoup.Connection.Request request42 = request38.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap43 = request38.headers();
request38.timeoutMilliseconds = 307;
request38.ignoreContentType = false;
java.util.Map<java.lang.String, java.lang.String> strMap48 = request38.cookies();
org.jsoup.Connection connection49 = httpConnection0.cookies(strMap48);
org.jsoup.Connection connection51 = httpConnection0.followRedirects(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
org.junit.Assert.assertTrue("'" + method39 + "' != '" + org.jsoup.Connection.Method.GET + "'", method39.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean40 + "' != '" + true + "'", boolean40 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection51);
}
@Test
public void test0797() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0797");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
boolean boolean7 = request5.ignoreHttpErrors();
org.jsoup.Connection.Request request10 = request5.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
java.util.Map<java.lang.String, java.lang.String> strMap13 = request11.headers();
request11.followRedirects = false;
boolean boolean16 = request11.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request18 = request11.timeout((int) ' ');
java.lang.String str20 = request18.cookie("hi!");
java.lang.String str22 = request18.header("null=null");
request18.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser30 = request25.parser;
request18.parser = parser30;
org.jsoup.helper.HttpConnection.Request request32 = request5.parser(parser30);
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
org.jsoup.Connection.Request request35 = request32.method(method34);
org.jsoup.Connection.Request request36 = request0.method(method34);
request0.followRedirects = false;
request0.ignoreContentType = true;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request32);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
}
@Test
public void test0798() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0798");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.helper.HttpConnection.Response response7 = null;
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response7);
java.lang.String str9 = response8.contentType();
java.lang.String str10 = response8.contentType();
int int11 = response8.statusCode();
httpConnection0.res = response8;
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
boolean boolean15 = request13.followRedirects;
org.jsoup.Connection.Request request17 = request13.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap18 = request13.headers();
boolean boolean19 = request13.ignoreContentType;
request13.ignoreHttpErrors = true;
java.net.URL uRL22 = request13.url();
org.jsoup.Connection.Request request24 = request13.ignoreContentType(false);
org.jsoup.Connection.Request request26 = request13.ignoreContentType(false);
httpConnection0.req = request13;
org.jsoup.Connection connection30 = httpConnection0.cookie("hi!=null", "null=");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response31 = httpConnection0.execute();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 0 + "'", int11 == 0);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + false + "'", boolean19 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection30);
}
@Test
public void test0799() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0799");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
boolean boolean9 = request7.followRedirects();
boolean boolean11 = request7.hasCookie("hi!");
request7.ignoreContentType = false;
boolean boolean14 = request7.followRedirects;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
}
@Test
public void test0800() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0800");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean3 = request0.hasHeader("null=null");
request0.ignoreContentType = true;
int int6 = request0.maxBodySize();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal7.key = "hi!";
java.lang.String str10 = keyVal7.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal12 = keyVal7.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal14 = keyVal12.key("null=hi!");
java.lang.String str15 = keyVal12.value;
java.lang.String str16 = keyVal12.key();
org.jsoup.helper.HttpConnection.Request request17 = request0.data((org.jsoup.Connection.KeyVal) keyVal12);
java.lang.String str19 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean3 + "' != '" + false + "'", boolean3 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str10 + "' != '" + "hi!" + "'", str10.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str16 + "' != '" + "null=hi!" + "'", str16.equals("null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
}
@Test
public void test0801() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0801");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection.Response response7 = httpConnection0.response();
org.jsoup.Connection connection9 = httpConnection0.ignoreHttpErrors(false);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response10 = httpConnection0.execute();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
}
@Test
public void test0802() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0802");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
org.jsoup.parser.Parser parser6 = null;
request0.parser = parser6;
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
org.jsoup.Connection connection11 = httpConnection8.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection12 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection15 = httpConnection12.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
java.util.Map<java.lang.String, java.lang.String> strMap18 = request16.headers();
int int19 = request16.timeout();
org.jsoup.parser.Parser parser20 = request16.parser();
org.jsoup.Connection connection21 = httpConnection12.parser(parser20);
org.jsoup.Connection connection22 = httpConnection8.parser(parser20);
org.jsoup.helper.HttpConnection.Request request23 = request0.parser(parser20);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 3000 + "'", int19 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
}
@Test
public void test0803() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0803");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.headers();
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = new org.jsoup.helper.HttpConnection.KeyVal("null=null", "hi!");
org.jsoup.helper.HttpConnection.Request request7 = request0.data((org.jsoup.Connection.KeyVal) keyVal6);
org.jsoup.helper.HttpConnection.Response response8 = null;
org.jsoup.helper.HttpConnection.Response response9 = new org.jsoup.helper.HttpConnection.Response(response8);
int int10 = response9.numRedirects;
response9.charset = "hi!=null";
org.jsoup.Connection.Response response14 = response9.removeCookie("null=null");
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response15 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request0, response9);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 0 + "'", int10 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response14);
}
@Test
public void test0804() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0804");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
request0.maxBodySizeBytes = (-1);
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.headers();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
}
@Test
public void test0805() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0805");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal0.key = "hi!";
java.lang.String str3 = keyVal0.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal0.key("hi!");
java.lang.String str6 = keyVal5.value;
java.lang.String str7 = keyVal5.key;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "hi!" + "'", str3.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str7 + "' != '" + "hi!" + "'", str7.equals("hi!"));
}
@Test
public void test0806() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0806");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.headers();
java.lang.String str5 = request0.getHeaderCaseInsensitive("null=hi!");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry7 = request0.scanHeaders("null=null");
java.lang.String str9 = request0.cookie("hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
}
@Test
public void test0807() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0807");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
boolean boolean9 = request0.ignoreHttpErrors();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + true + "'", boolean9 == true);
}
@Test
public void test0808() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0808");
org.jsoup.helper.HttpConnection.Response.MAX_REDIRECTS = '4';
}
@Test
public void test0809() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0809");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection connection9 = httpConnection0.cookie("null=null", "null=null");
org.jsoup.Connection connection11 = httpConnection0.ignoreHttpErrors(true);
org.jsoup.Connection connection13 = httpConnection0.followRedirects(true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
}
@Test
public void test0810() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0810");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
org.jsoup.Connection.Method method2 = response1.method();
org.jsoup.Connection.Response response4 = response1.removeHeader("hi!");
boolean boolean6 = response1.hasCookie("hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
}
@Test
public void test0811() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0811");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request0.followRedirects();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection9 = request0.data();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry11 = request0.scanHeaders("null=hi!");
request0.timeoutMilliseconds = (byte) -1;
org.jsoup.parser.Parser parser14 = request0.parser;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser14);
}
@Test
public void test0812() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0812");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
int int8 = request0.timeout();
org.jsoup.helper.HttpConnection httpConnection9 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection11 = httpConnection9.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean18 = request12.hasCookie("null=null");
java.lang.String str20 = request12.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection connection21 = httpConnection9.request((org.jsoup.Connection.Request) request12);
org.jsoup.helper.HttpConnection httpConnection22 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response23 = httpConnection22.response();
httpConnection9.res = response23;
org.jsoup.Connection connection26 = httpConnection9.ignoreHttpErrors(false);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection.Request request29 = httpConnection27.request();
org.jsoup.Connection.Request request30 = httpConnection27.req;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
boolean boolean33 = request31.ignoreHttpErrors();
org.jsoup.Connection.Request request36 = request31.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
request37.followRedirects = false;
boolean boolean42 = request37.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request44 = request37.timeout((int) ' ');
java.lang.String str46 = request44.cookie("hi!");
java.lang.String str48 = request44.header("null=null");
request44.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
java.util.Map<java.lang.String, java.lang.String> strMap53 = request51.headers();
request51.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser56 = request51.parser;
request44.parser = parser56;
org.jsoup.helper.HttpConnection.Request request58 = request31.parser(parser56);
org.jsoup.helper.HttpConnection.Request request59 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method60 = request59.method();
org.jsoup.Connection.Request request61 = request58.method(method60);
org.jsoup.Connection connection62 = httpConnection27.method(method60);
org.jsoup.Connection connection63 = httpConnection9.method(method60);
org.jsoup.Connection.Request request64 = request0.method(method60);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 3000 + "'", int8 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + false + "'", boolean18 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + false + "'", boolean42 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request64);
}
@Test
public void test0813() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0813");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
org.jsoup.Connection.Request request11 = request7.ignoreContentType(true);
org.jsoup.Connection.Request request13 = request7.removeCookie("null=null=null=hi!");
// The following exception was thrown during execution in test generation
try {
boolean boolean15 = request7.hasHeader("");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
}
@Test
public void test0814() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0814");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
boolean boolean3 = response1.hasCookie("hi!=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean3 + "' != '" + false + "'", boolean3 == false);
}
@Test
public void test0815() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0815");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Request request4 = null;
httpConnection0.req = request4;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection8 = httpConnection0.data("null=null=hi!", "null=hi!");
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
}
@Test
public void test0816() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0816");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
boolean boolean9 = request7.followRedirects();
boolean boolean11 = request7.hasCookie("hi!");
java.net.URL uRL12 = request7.url();
request7.ignoreContentType = true;
org.jsoup.Connection.Request request16 = request7.removeHeader("null=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
}
@Test
public void test0817() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0817");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request9 = request0.timeout((int) (byte) 0);
org.jsoup.Connection.Request request11 = request9.removeCookie("hi!");
org.jsoup.Connection.Request request14 = request9.header("null=hi!", "");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
}
@Test
public void test0818() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0818");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.parser.Parser parser7 = null;
org.jsoup.Connection connection8 = httpConnection0.parser(parser7);
org.jsoup.helper.HttpConnection httpConnection9 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection11 = httpConnection9.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean17 = request12.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request19 = request12.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry21 = request12.scanHeaders("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap22 = request12.headers();
org.jsoup.Connection connection23 = httpConnection9.data(strMap22);
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
java.util.Map<java.lang.String, java.lang.String> strMap26 = request24.headers();
request24.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser29 = request24.parser;
org.jsoup.Connection.Request request31 = request24.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap32 = request24.headers();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request24.cookies();
org.jsoup.Connection connection34 = httpConnection9.data(strMap33);
org.jsoup.helper.HttpConnection httpConnection35 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response36 = httpConnection35.response();
org.jsoup.Connection.Request request37 = httpConnection35.request();
org.jsoup.Connection connection39 = httpConnection35.ignoreContentType(true);
org.jsoup.Connection.Request request40 = httpConnection35.request();
org.jsoup.Connection connection42 = httpConnection35.referrer("null=hi!");
org.jsoup.helper.HttpConnection httpConnection43 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request44 = null;
org.jsoup.Connection connection45 = httpConnection43.request(request44);
org.jsoup.helper.HttpConnection httpConnection46 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response47 = httpConnection46.response();
org.jsoup.Connection.Request request48 = httpConnection46.request();
org.jsoup.Connection connection49 = httpConnection43.request(request48);
org.jsoup.helper.HttpConnection httpConnection50 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection52 = httpConnection50.followRedirects(false);
org.jsoup.Connection connection54 = httpConnection50.referrer("");
org.jsoup.Connection.Response response55 = httpConnection50.response();
org.jsoup.Connection connection56 = httpConnection43.response(response55);
org.jsoup.Connection connection58 = httpConnection43.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request59 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method60 = request59.method();
boolean boolean61 = request59.ignoreHttpErrors();
org.jsoup.Connection.Request request64 = request59.cookie("hi!", "");
java.lang.String str66 = request59.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request67 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method68 = request67.method();
boolean boolean69 = request67.followRedirects;
org.jsoup.Connection.Request request71 = request67.followRedirects(true);
java.lang.String str73 = request67.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request74 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method75 = request74.method();
org.jsoup.Connection.Request request76 = request67.method(method75);
org.jsoup.Connection.Request request77 = request59.method(method75);
org.jsoup.Connection connection78 = httpConnection43.method(method75);
org.jsoup.Connection connection80 = httpConnection43.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection81 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response82 = httpConnection81.response();
org.jsoup.Connection connection84 = httpConnection81.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection85 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response86 = httpConnection85.response();
httpConnection81.res = response86;
java.lang.String[] strArray90 = new java.lang.String[] { "null=null", "null=null" };
org.jsoup.Connection connection91 = httpConnection81.data(strArray90);
org.jsoup.Connection connection92 = httpConnection43.data(strArray90);
org.jsoup.Connection connection93 = httpConnection35.data(strArray90);
org.jsoup.Connection connection94 = httpConnection9.data(strArray90);
org.jsoup.Connection connection95 = httpConnection0.data(strArray90);
org.jsoup.Connection connection97 = httpConnection0.maxBodySize((int) (byte) 1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection58);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean61 + "' != '" + false + "'", boolean61 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str66);
org.junit.Assert.assertTrue("'" + method68 + "' != '" + org.jsoup.Connection.Method.GET + "'", method68.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean69 + "' != '" + true + "'", boolean69 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str73);
org.junit.Assert.assertTrue("'" + method75 + "' != '" + org.jsoup.Connection.Method.GET + "'", method75.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection78);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response82);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection84);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response86);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray90);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection91);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection92);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection93);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection94);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection95);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection97);
}
@Test
public void test0819() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0819");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.parser.Parser parser3 = null;
org.jsoup.Connection connection4 = httpConnection0.parser(parser3);
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.Connection.Response response6 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
boolean boolean11 = request9.followRedirects;
org.jsoup.Connection.Request request13 = request9.followRedirects(true);
java.lang.String str15 = request9.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
org.jsoup.Connection.Request request18 = request9.method(method17);
org.jsoup.Connection.Request request19 = request7.method(method17);
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str21 = keyVal20.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal23 = keyVal20.value("");
java.lang.String str24 = keyVal20.value();
org.jsoup.helper.HttpConnection.Request request25 = request7.data((org.jsoup.Connection.KeyVal) keyVal20);
int int26 = request25.timeout();
boolean boolean27 = request25.followRedirects;
org.jsoup.Connection.Request request30 = request25.cookie("null=hi!", "hi!");
boolean boolean32 = request25.hasHeader("null=");
org.jsoup.Connection connection33 = httpConnection0.request((org.jsoup.Connection.Request) request25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + true + "'", boolean11 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str21 + "' != '" + "null=null" + "'", str21.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str24 + "' != '" + "" + "'", str24.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 3000 + "'", int26 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + true + "'", boolean27 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
}
@Test
public void test0820() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0820");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser5 = request0.parser;
org.jsoup.Connection.Request request7 = request0.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap8 = request0.headers();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry10 = request0.scanHeaders("null=hi!");
org.jsoup.parser.Parser parser11 = request0.parser;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser11);
}
@Test
public void test0821() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0821");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.net.URL uRL7 = response1.url();
response1.statusCode = 10;
response1.executed = true;
java.util.Map<java.lang.String, java.lang.String> strMap12 = response1.cookies();
response1.executed = true;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
}
@Test
public void test0822() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0822");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
java.lang.String str4 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal0.value("hi!");
java.lang.String str7 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal0.value("null=null");
java.lang.String str10 = keyVal9.value();
org.jsoup.helper.HttpConnection.KeyVal keyVal12 = keyVal9.value("");
keyVal9.value = "hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal9.value("null=null=");
keyVal16.value = "null=null=";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str10 + "' != '" + "null=null" + "'", str10.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
}
@Test
public void test0823() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0823");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.util.Map<java.lang.String, java.lang.String> strMap7 = response1.cookies();
int int8 = response1.statusCode();
java.lang.String str9 = response1.statusMessage;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
}
@Test
public void test0824() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0824");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.Connection.Request request7 = httpConnection5.request();
response1.req = request7;
response1.executed = false;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
}
@Test
public void test0825() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0825");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.helper.HttpConnection.Request request4 = request0.timeout((int) (short) 0);
org.jsoup.Connection.Method method5 = request0.method();
boolean boolean6 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request8 = request0.timeout((int) (byte) 100);
boolean boolean9 = request8.ignoreHttpErrors();
org.jsoup.parser.Parser parser10 = request8.parser();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method5 + "' != '" + org.jsoup.Connection.Method.GET + "'", method5.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser10);
}
@Test
public void test0826() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0826");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection connection4 = httpConnection0.ignoreContentType(true);
org.jsoup.Connection.Request request5 = httpConnection0.request();
org.jsoup.Connection connection7 = httpConnection0.referrer("null=hi!");
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request9 = null;
org.jsoup.Connection connection10 = httpConnection8.request(request9);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
org.jsoup.Connection.Request request13 = httpConnection11.request();
org.jsoup.Connection connection14 = httpConnection8.request(request13);
org.jsoup.helper.HttpConnection httpConnection15 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection17 = httpConnection15.followRedirects(false);
org.jsoup.Connection connection19 = httpConnection15.referrer("");
org.jsoup.Connection.Response response20 = httpConnection15.response();
org.jsoup.Connection connection21 = httpConnection8.response(response20);
org.jsoup.Connection connection23 = httpConnection8.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
boolean boolean26 = request24.ignoreHttpErrors();
org.jsoup.Connection.Request request29 = request24.cookie("hi!", "");
java.lang.String str31 = request24.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
boolean boolean34 = request32.followRedirects;
org.jsoup.Connection.Request request36 = request32.followRedirects(true);
java.lang.String str38 = request32.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request32.method(method40);
org.jsoup.Connection.Request request42 = request24.method(method40);
org.jsoup.Connection connection43 = httpConnection8.method(method40);
org.jsoup.Connection connection45 = httpConnection8.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection46 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response47 = httpConnection46.response();
org.jsoup.Connection connection49 = httpConnection46.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection50 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response51 = httpConnection50.response();
httpConnection46.res = response51;
java.lang.String[] strArray55 = new java.lang.String[] { "null=null", "null=null" };
org.jsoup.Connection connection56 = httpConnection46.data(strArray55);
org.jsoup.Connection connection57 = httpConnection8.data(strArray55);
org.jsoup.Connection connection58 = httpConnection0.data(strArray55);
org.jsoup.Connection connection60 = httpConnection0.referrer("null=null=null=hi!=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + false + "'", boolean26 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str31);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean34 + "' != '" + true + "'", boolean34 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str38);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection60);
}
@Test
public void test0827() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0827");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str7 = response1.cookie("null=null");
response1.executed = false;
java.lang.String str10 = response1.contentType();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
}
@Test
public void test0828() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0828");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection.Request request5 = httpConnection3.request();
org.jsoup.Connection connection6 = httpConnection0.request(request5);
org.jsoup.Connection connection9 = httpConnection0.cookie("null=null", "null=null");
org.jsoup.Connection connection11 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
boolean boolean14 = request12.followRedirects;
org.jsoup.Connection.Request request16 = request12.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap17 = request12.cookies();
org.jsoup.Connection connection18 = httpConnection0.data(strMap17);
org.jsoup.Connection connection20 = httpConnection0.ignoreContentType(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + true + "'", boolean14 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
}
@Test
public void test0829() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0829");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap1 = request0.headers();
org.jsoup.Connection.Request request3 = request0.removeHeader("null=null=null=hi!");
org.jsoup.Connection.Request request5 = request0.removeHeader("null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
}
@Test
public void test0830() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0830");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
request6.ignoreHttpErrors = true;
java.net.URL uRL18 = request6.url();
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
boolean boolean21 = request19.followRedirects;
org.jsoup.Connection.Request request23 = request19.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap24 = request19.headers();
boolean boolean25 = request19.ignoreContentType;
request19.followRedirects = false;
int int28 = request19.timeout();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection29 = request19.data;
org.jsoup.helper.HttpConnection.Request request30 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method31 = request30.method();
boolean boolean32 = request30.followRedirects;
org.jsoup.Connection.Request request34 = request30.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap35 = request30.cookies();
boolean boolean37 = request30.hasCookie("null=null");
org.jsoup.parser.Parser parser38 = request30.parser();
request19.parser = parser38;
request6.parser = parser38;
java.net.URL uRL41 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request42 = request6.url(uRL41);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL18);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + true + "'", boolean21 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int28 + "' != '" + 3000 + "'", int28 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection29);
org.junit.Assert.assertTrue("'" + method31 + "' != '" + org.jsoup.Connection.Method.GET + "'", method31.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + true + "'", boolean32 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser38);
}
@Test
public void test0831() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0831");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str6 = response1.getHeaderCaseInsensitive("null=null");
java.lang.String str7 = response1.statusMessage;
java.lang.String str9 = response1.getHeaderCaseInsensitive("null=null=");
java.net.URL uRL10 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response11 = response1.url(uRL10);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
}
@Test
public void test0832() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0832");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
java.lang.String str3 = response1.contentType();
java.net.URL uRL4 = response1.url();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL4);
}
@Test
public void test0833() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0833");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.net.URL uRL7 = response1.url();
response1.statusCode = 10;
response1.executed = true;
java.util.Map<java.lang.String, java.lang.String> strMap12 = response1.cookies();
response1.contentType = "null=null=";
java.net.URL uRL15 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response16 = response1.url(uRL15);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
}
@Test
public void test0834() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0834");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.ignoreHttpErrors();
org.jsoup.Connection.Request request16 = request11.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
boolean boolean22 = request17.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request24 = request17.timeout((int) ' ');
java.lang.String str26 = request24.cookie("hi!");
java.lang.String str28 = request24.header("null=null");
request24.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser36 = request31.parser;
request24.parser = parser36;
org.jsoup.helper.HttpConnection.Request request38 = request11.parser(parser36);
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request38.method(method40);
org.jsoup.Connection.Request request42 = request6.method(method40);
org.jsoup.Connection.Response response43 = response1.method(method40);
org.jsoup.helper.HttpConnection.Response response44 = new org.jsoup.helper.HttpConnection.Response(response1);
org.jsoup.Connection.Method method45 = response44.method();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str28);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method45);
}
@Test
public void test0835() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0835");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.Connection.Response response7 = response1.removeHeader("hi!");
boolean boolean9 = response1.hasHeader("hi!=");
java.util.Map<java.lang.String, java.lang.String> strMap10 = response1.cookies();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
}
@Test
public void test0836() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0836");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
org.jsoup.parser.Parser parser9 = request7.parser;
java.util.Map<java.lang.String, java.lang.String> strMap10 = request7.headers();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
}
@Test
public void test0837() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0837");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
org.jsoup.Connection.Request request11 = request6.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean17 = request12.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request19 = request12.timeout((int) ' ');
java.lang.String str21 = request19.cookie("hi!");
java.lang.String str23 = request19.header("null=null");
request19.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser31 = request26.parser;
request19.parser = parser31;
org.jsoup.helper.HttpConnection.Request request33 = request6.parser(parser31);
org.jsoup.Connection connection34 = httpConnection0.request((org.jsoup.Connection.Request) request33);
org.jsoup.Connection connection36 = httpConnection0.userAgent("");
org.jsoup.helper.HttpConnection.Response response37 = null;
org.jsoup.helper.HttpConnection.Response response38 = new org.jsoup.helper.HttpConnection.Response(response37);
int int39 = response38.numRedirects;
response38.charset = "hi!=null";
org.jsoup.Connection.Response response43 = response38.removeCookie("null=null");
org.jsoup.Connection connection44 = httpConnection0.response(response43);
org.jsoup.Connection connection46 = httpConnection0.referrer("hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 0 + "'", int39 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection46);
}
@Test
public void test0838() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0838");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request7.headers();
org.jsoup.Connection connection9 = httpConnection0.request((org.jsoup.Connection.Request) request7);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry11 = request7.scanHeaders("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal12 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal12.key = "hi!";
java.lang.String str15 = keyVal12.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal17 = keyVal12.key("hi!");
java.lang.String str18 = keyVal12.value();
keyVal12.key = "null=";
org.jsoup.helper.HttpConnection.KeyVal keyVal22 = keyVal12.value("null=null=hi!");
org.jsoup.helper.HttpConnection.Request request23 = request7.data((org.jsoup.Connection.KeyVal) keyVal12);
java.lang.String str24 = keyVal12.value;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str15 + "' != '" + "hi!" + "'", str15.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str24 + "' != '" + "null=null=hi!" + "'", str24.equals("null=null=hi!"));
}
@Test
public void test0839() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0839");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.followRedirects(true);
org.jsoup.Connection connection19 = httpConnection0.ignoreHttpErrors(false);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection22 = httpConnection0.data("", "hi!=null");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Data key must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
}
@Test
public void test0840() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0840");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
response1.statusMessage = "null=";
int int7 = response1.statusCode;
response1.contentType = "";
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response12 = response1.cookie("", "null=null=");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Cookie name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
}
@Test
public void test0841() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0841");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
java.lang.String str8 = response1.statusMessage;
int int9 = response1.numRedirects;
org.jsoup.helper.HttpConnection.Response response10 = null;
org.jsoup.helper.HttpConnection.Response response11 = new org.jsoup.helper.HttpConnection.Response(response10);
int int12 = response11.statusCode();
int int13 = response11.numRedirects;
response11.charset = "";
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
org.jsoup.Connection.Request request19 = request16.ignoreContentType(false);
org.jsoup.Connection.Request request21 = request16.removeCookie("");
int int22 = request16.maxBodySize();
org.jsoup.Connection.Request request24 = request16.followRedirects(false);
response11.req = request16;
request16.ignoreHttpErrors = true;
org.jsoup.Connection.Method method28 = request16.method();
org.jsoup.Connection.Response response29 = response1.method(method28);
java.net.HttpURLConnection httpURLConnection30 = null;
org.jsoup.helper.HttpConnection httpConnection31 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request32 = null;
org.jsoup.Connection connection33 = httpConnection31.request(request32);
org.jsoup.helper.HttpConnection httpConnection34 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response35 = httpConnection34.response();
org.jsoup.Connection.Request request36 = httpConnection34.request();
org.jsoup.Connection connection37 = httpConnection31.request(request36);
org.jsoup.Connection.Request request38 = httpConnection31.req;
org.jsoup.Connection connection40 = httpConnection31.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request41 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method42 = request41.method();
boolean boolean43 = request41.followRedirects;
org.jsoup.Connection.Request request45 = request41.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap46 = request41.headers();
boolean boolean47 = request41.ignoreContentType;
request41.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap50 = request41.cookies();
httpConnection31.req = request41;
org.jsoup.Connection.Response response52 = httpConnection31.response();
// The following exception was thrown during execution in test generation
try {
response1.setupFromConnection(httpURLConnection30, response52);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 0 + "'", int13 == 0);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 1048576 + "'", int22 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
org.junit.Assert.assertTrue("'" + method28 + "' != '" + org.jsoup.Connection.Method.GET + "'", method28.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection40);
org.junit.Assert.assertTrue("'" + method42 + "' != '" + org.jsoup.Connection.Method.GET + "'", method42.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean43 + "' != '" + true + "'", boolean43 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response52);
}
@Test
public void test0842() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0842");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
java.net.URL uRL15 = request0.url();
org.jsoup.Connection.Request request17 = request0.removeCookie("");
org.jsoup.Connection.Request request19 = request0.removeCookie("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap20 = request0.headers();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap20);
}
@Test
public void test0843() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0843");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
java.lang.String str19 = org.jsoup.helper.HttpConnection.Response.getRequestCookieString((org.jsoup.Connection.Request) request18);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str19 + "' != '" + "" + "'", str19.equals(""));
}
@Test
public void test0844() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0844");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection19 = httpConnection0.referrer("hi!");
org.jsoup.helper.HttpConnection httpConnection20 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response21 = httpConnection20.response();
org.jsoup.Connection connection23 = httpConnection20.followRedirects(false);
org.jsoup.Connection.Response response24 = httpConnection20.response();
httpConnection0.res = response24;
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
java.util.Map<java.lang.String, java.lang.String> strMap29 = request26.headers();
org.jsoup.Connection.Method method30 = request26.method();
org.jsoup.Connection connection31 = httpConnection0.method(method30);
org.jsoup.Connection connection33 = httpConnection0.timeout((int) (byte) 0);
org.jsoup.helper.HttpConnection.Request request34 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method35 = request34.method();
boolean boolean36 = request34.followRedirects;
org.jsoup.Connection.Request request38 = request34.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap39 = request34.cookies();
org.jsoup.helper.HttpConnection.KeyVal keyVal42 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "");
org.jsoup.helper.HttpConnection.Request request43 = request34.data((org.jsoup.Connection.KeyVal) keyVal42);
org.jsoup.helper.HttpConnection httpConnection44 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response45 = httpConnection44.response();
org.jsoup.Connection.Request request46 = httpConnection44.request();
org.jsoup.Connection.Request request47 = httpConnection44.req;
org.jsoup.Connection connection49 = httpConnection44.timeout((int) 'a');
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
boolean boolean52 = request50.ignoreHttpErrors();
org.jsoup.Connection.Request request55 = request50.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request56 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method57 = request56.method();
java.util.Map<java.lang.String, java.lang.String> strMap58 = request56.headers();
request56.followRedirects = false;
boolean boolean61 = request56.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request63 = request56.timeout((int) ' ');
java.lang.String str65 = request63.cookie("hi!");
java.lang.String str67 = request63.header("null=null");
request63.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request70 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method71 = request70.method();
java.util.Map<java.lang.String, java.lang.String> strMap72 = request70.headers();
request70.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser75 = request70.parser;
request63.parser = parser75;
org.jsoup.helper.HttpConnection.Request request77 = request50.parser(parser75);
org.jsoup.Connection connection78 = httpConnection44.request((org.jsoup.Connection.Request) request77);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection79 = request77.data;
request34.data = keyValCollection79;
org.jsoup.Connection connection81 = httpConnection0.data(keyValCollection79);
org.jsoup.helper.HttpConnection.Request request82 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method83 = request82.method();
boolean boolean84 = request82.followRedirects;
org.jsoup.Connection.Request request86 = request82.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap87 = request82.headers();
boolean boolean88 = request82.ignoreContentType;
request82.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap91 = request82.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap92 = request82.cookies();
org.jsoup.Connection connection93 = httpConnection0.cookies(strMap92);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response24);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap29);
org.junit.Assert.assertTrue("'" + method30 + "' != '" + org.jsoup.Connection.Method.GET + "'", method30.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
org.junit.Assert.assertTrue("'" + method35 + "' != '" + org.jsoup.Connection.Method.GET + "'", method35.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + true + "'", boolean36 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection49);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + false + "'", boolean52 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request55);
org.junit.Assert.assertTrue("'" + method57 + "' != '" + org.jsoup.Connection.Method.GET + "'", method57.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean61 + "' != '" + false + "'", boolean61 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str67);
org.junit.Assert.assertTrue("'" + method71 + "' != '" + org.jsoup.Connection.Method.GET + "'", method71.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection78);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection79);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection81);
org.junit.Assert.assertTrue("'" + method83 + "' != '" + org.jsoup.Connection.Method.GET + "'", method83.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean84 + "' != '" + true + "'", boolean84 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request86);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap87);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean88 + "' != '" + false + "'", boolean88 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap91);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap92);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection93);
}
@Test
public void test0845() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0845");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
org.jsoup.Connection.Request request14 = request7.header("null=null=null=hi!", "");
org.jsoup.helper.HttpConnection httpConnection15 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection18 = httpConnection15.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
java.util.Map<java.lang.String, java.lang.String> strMap21 = request19.headers();
int int22 = request19.timeout();
org.jsoup.parser.Parser parser23 = request19.parser();
org.jsoup.Connection connection24 = httpConnection15.parser(parser23);
org.jsoup.helper.HttpConnection httpConnection25 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response26 = httpConnection25.response();
org.jsoup.Connection connection28 = httpConnection25.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response30 = httpConnection29.response();
httpConnection25.res = response30;
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request32.headers();
org.jsoup.Connection connection34 = httpConnection25.request((org.jsoup.Connection.Request) request32);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry36 = request32.scanHeaders("null=null");
org.jsoup.Connection.Request request38 = request32.ignoreContentType(false);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection39 = request32.data;
org.jsoup.helper.HttpConnection.Request request40 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method41 = request40.method();
org.jsoup.Connection.Request request43 = request40.ignoreContentType(false);
org.jsoup.Connection.Request request45 = request40.removeCookie("");
int int46 = request40.maxBodySize();
org.jsoup.Connection.Request request48 = request40.followRedirects(false);
java.lang.String str50 = request40.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
java.util.Map<java.lang.String, java.lang.String> strMap53 = request51.headers();
request51.followRedirects = false;
boolean boolean56 = request51.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request58 = request51.timeout((int) ' ');
java.lang.String str60 = request58.cookie("hi!");
java.lang.String str62 = request58.header("null=null");
request58.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request65 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method66 = request65.method();
java.util.Map<java.lang.String, java.lang.String> strMap67 = request65.headers();
request65.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser70 = request65.parser;
request58.parser = parser70;
request40.parser = parser70;
org.jsoup.helper.HttpConnection.Request request73 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method74 = request73.method();
boolean boolean75 = request73.ignoreHttpErrors();
org.jsoup.Connection.Request request78 = request73.cookie("hi!", "");
boolean boolean79 = request73.ignoreContentType;
org.jsoup.parser.Parser parser80 = request73.parser();
request40.parser = parser80;
request32.parser = parser80;
org.jsoup.Connection connection83 = httpConnection15.parser(parser80);
request7.parser = parser80;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection18);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 3000 + "'", int22 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection39);
org.junit.Assert.assertTrue("'" + method41 + "' != '" + org.jsoup.Connection.Method.GET + "'", method41.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int46 + "' != '" + 1048576 + "'", int46 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str50);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + false + "'", boolean56 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str62);
org.junit.Assert.assertTrue("'" + method66 + "' != '" + org.jsoup.Connection.Method.GET + "'", method66.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser70);
org.junit.Assert.assertTrue("'" + method74 + "' != '" + org.jsoup.Connection.Method.GET + "'", method74.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean75 + "' != '" + false + "'", boolean75 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request78);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean79 + "' != '" + false + "'", boolean79 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection83);
}
@Test
public void test0846() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0846");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str7 = response1.cookie("null=null");
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response1);
response1.statusCode = 0;
java.lang.String str11 = response1.charset;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
}
@Test
public void test0847() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0847");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
response1.statusMessage = "null=";
int int7 = response1.statusCode;
response1.contentType = "";
java.util.Map<java.lang.String, java.lang.String> strMap10 = response1.cookies();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int7 + "' != '" + 0 + "'", int7 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
}
@Test
public void test0848() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0848");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal2.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal2.value("null=null");
java.lang.String str7 = keyVal2.value();
java.lang.String str8 = keyVal2.value();
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal2.value("");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str7 + "' != '" + "null=null" + "'", str7.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str8 + "' != '" + "null=null" + "'", str8.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
}
@Test
public void test0849() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0849");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection5 = httpConnection0.header("null=null=hi!", "hi!=null=hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
}
@Test
public void test0850() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0850");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean9 = request3.hasCookie("null=null");
java.lang.String str11 = request3.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection connection12 = httpConnection0.request((org.jsoup.Connection.Request) request3);
org.jsoup.Connection connection15 = httpConnection0.data("null=hi!", "");
org.jsoup.Connection connection17 = httpConnection0.maxBodySize(32);
org.jsoup.Connection.Request request18 = httpConnection0.request();
org.jsoup.helper.HttpConnection.Response response19 = null;
org.jsoup.helper.HttpConnection.Response response20 = new org.jsoup.helper.HttpConnection.Response(response19);
int int21 = response20.numRedirects;
response20.charset = "hi!=null";
java.lang.String str25 = response20.getHeaderCaseInsensitive("null=null");
org.jsoup.Connection connection26 = httpConnection0.response((org.jsoup.Connection.Response) response20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 0 + "'", int21 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
}
@Test
public void test0851() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0851");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
boolean boolean6 = request0.ignoreContentType;
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "hi!");
java.lang.String str11 = request0.getHeaderCaseInsensitive("");
java.lang.String str13 = request0.cookie("");
request0.ignoreContentType = false;
java.util.Map<java.lang.String, java.lang.String> strMap16 = request0.cookies();
boolean boolean17 = request0.followRedirects();
org.jsoup.helper.HttpConnection.KeyVal keyVal18 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal18.key = "hi!";
java.lang.String str21 = keyVal18.key;
org.jsoup.helper.HttpConnection.Request request22 = request0.data((org.jsoup.Connection.KeyVal) keyVal18);
org.jsoup.Connection.Method method23 = request22.method();
java.lang.String str25 = request22.header("hi!=null=hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str21 + "' != '" + "hi!" + "'", str21.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str25);
}
@Test
public void test0852() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0852");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("null=hi!", "null=hi!");
java.lang.String str3 = keyVal2.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal2.value("null=null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "null=hi!" + "'", str3.equals("null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
}
@Test
public void test0853() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0853");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection5 = httpConnection0.ignoreHttpErrors(true);
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
boolean boolean14 = request13.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal17 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal17.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal23 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal25 = keyVal23.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal26 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal26.key = "hi!";
java.lang.String str29 = keyVal26.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal31 = keyVal26.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal34 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal35.key = "hi!";
java.lang.String str38 = keyVal35.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str40 = keyVal39.toString();
keyVal39.value = "";
keyVal39.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal45.key = "hi!";
java.lang.String str48 = keyVal45.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal50 = keyVal45.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal51 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str52 = keyVal51.key();
org.jsoup.Connection.KeyVal[] keyValArray53 = new org.jsoup.Connection.KeyVal[] { keyVal17, keyVal20, keyVal25, keyVal26, keyVal34, keyVal35, keyVal39, keyVal45, keyVal51 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList54 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean55 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54, keyValArray53);
request13.data = keyValList54;
org.jsoup.Connection connection57 = httpConnection0.data((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54);
java.io.OutputStream outputStream58 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response.writePost((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54, outputStream58);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str29 + "' != '" + "hi!" + "'", str29.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str38 + "' != '" + "hi!" + "'", str38.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str40 + "' != '" + "null=null" + "'", str40.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str48 + "' != '" + "hi!" + "'", str48.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean55 + "' != '" + true + "'", boolean55 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
}
@Test
public void test0854() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0854");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str6 = response1.contentType;
java.lang.String str7 = response1.statusMessage;
// The following exception was thrown during execution in test generation
try {
byte[] byteArray8 = response1.bodyAsBytes();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before getting response body");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
}
@Test
public void test0855() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0855");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal0.key("hi!");
java.lang.String str6 = keyVal0.value;
keyVal0.key = "hi!";
keyVal0.key = "null=null=null=hi!";
java.lang.String str11 = keyVal0.key();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str6 + "' != '" + "hi!" + "'", str6.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str11 + "' != '" + "null=null=null=hi!" + "'", str11.equals("null=null=null=hi!"));
}
@Test
public void test0856() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0856");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
java.lang.String str7 = response1.statusMessage;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = response1.scanHeaders("null=null=hi!");
org.jsoup.Connection.Response response11 = response1.removeHeader("hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
}
@Test
public void test0857() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0857");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap1 = request0.headers();
org.jsoup.Connection.Request request3 = request0.removeHeader("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
boolean boolean14 = request13.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal17 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal17.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal20 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal23 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal25 = keyVal23.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal26 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal26.key = "hi!";
java.lang.String str29 = keyVal26.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal31 = keyVal26.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal34 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal35.key = "hi!";
java.lang.String str38 = keyVal35.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str40 = keyVal39.toString();
keyVal39.value = "";
keyVal39.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal45.key = "hi!";
java.lang.String str48 = keyVal45.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal50 = keyVal45.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal51 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str52 = keyVal51.key();
org.jsoup.Connection.KeyVal[] keyValArray53 = new org.jsoup.Connection.KeyVal[] { keyVal17, keyVal20, keyVal25, keyVal26, keyVal34, keyVal35, keyVal39, keyVal45, keyVal51 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList54 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean55 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList54, keyValArray53);
request13.data = keyValList54;
org.jsoup.helper.HttpConnection.Request request57 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method58 = request57.method();
java.util.Map<java.lang.String, java.lang.String> strMap59 = request57.headers();
request57.followRedirects = false;
java.lang.String str63 = request57.cookie("");
boolean boolean64 = request57.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request65 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method66 = request65.method();
java.util.Map<java.lang.String, java.lang.String> strMap67 = request65.headers();
request65.followRedirects = false;
boolean boolean70 = request65.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection71 = request65.data();
request57.data = keyValCollection71;
request13.data = keyValCollection71;
org.jsoup.Connection connection74 = httpConnection4.data(keyValCollection71);
request0.data = keyValCollection71;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str29 + "' != '" + "hi!" + "'", str29.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str38 + "' != '" + "hi!" + "'", str38.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str40 + "' != '" + "null=null" + "'", str40.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str48 + "' != '" + "hi!" + "'", str48.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean55 + "' != '" + true + "'", boolean55 == true);
org.junit.Assert.assertTrue("'" + method58 + "' != '" + org.jsoup.Connection.Method.GET + "'", method58.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean64 + "' != '" + false + "'", boolean64 == false);
org.junit.Assert.assertTrue("'" + method66 + "' != '" + org.jsoup.Connection.Method.GET + "'", method66.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean70 + "' != '" + false + "'", boolean70 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection74);
}
@Test
public void test0858() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0858");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "null=null");
java.lang.String str11 = request0.getHeaderCaseInsensitive("hi!=");
boolean boolean12 = request0.followRedirects();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection13 = request0.data;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection13);
}
@Test
public void test0859() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0859");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.ignoreContentType;
java.lang.String str10 = request7.header("hi!");
org.jsoup.Connection.Request request12 = request7.removeHeader("hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
}
@Test
public void test0860() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0860");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
int int8 = request7.timeoutMilliseconds;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 32 + "'", int8 == 32);
}
@Test
public void test0861() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0861");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
org.jsoup.helper.HttpConnection.KeyVal keyVal8 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "");
org.jsoup.helper.HttpConnection.Request request9 = request0.data((org.jsoup.Connection.KeyVal) keyVal8);
java.lang.String str11 = request9.cookie("null=null=null=hi!");
java.net.URL uRL12 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Request request13 = request9.url(uRL12);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
}
@Test
public void test0862() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0862");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.util.Map<java.lang.String, java.lang.String> strMap2 = response1.headers();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
}
@Test
public void test0863() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0863");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.referrer("");
org.jsoup.Connection connection6 = httpConnection0.ignoreContentType(false);
org.jsoup.Connection connection8 = httpConnection0.maxBodySize((int) (byte) 0);
org.jsoup.Connection.Response response9 = httpConnection0.response();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
}
@Test
public void test0864() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0864");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.ignoreHttpErrors();
org.jsoup.Connection.Request request16 = request11.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
boolean boolean22 = request17.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request24 = request17.timeout((int) ' ');
java.lang.String str26 = request24.cookie("hi!");
java.lang.String str28 = request24.header("null=null");
request24.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser36 = request31.parser;
request24.parser = parser36;
org.jsoup.helper.HttpConnection.Request request38 = request11.parser(parser36);
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
org.jsoup.Connection.Request request41 = request38.method(method40);
org.jsoup.Connection.Request request42 = request6.method(method40);
org.jsoup.Connection.Response response43 = response1.method(method40);
java.util.Map<java.lang.String, java.lang.String> strMap44 = response1.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap45 = response1.cookies();
org.jsoup.helper.HttpConnection httpConnection46 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request47 = null;
org.jsoup.Connection connection48 = httpConnection46.request(request47);
org.jsoup.helper.HttpConnection httpConnection49 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response50 = httpConnection49.response();
org.jsoup.Connection.Request request51 = httpConnection49.request();
org.jsoup.Connection connection52 = httpConnection46.request(request51);
org.jsoup.Connection.Response response53 = httpConnection46.response();
org.jsoup.Connection connection55 = httpConnection46.ignoreHttpErrors(false);
org.jsoup.helper.HttpConnection.Request request56 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method57 = request56.method();
boolean boolean58 = request56.ignoreHttpErrors();
org.jsoup.Connection.Request request61 = request56.cookie("hi!", "");
boolean boolean62 = request56.ignoreContentType;
org.jsoup.Connection.Request request65 = request56.cookie("null=hi!", "hi!");
java.lang.String str67 = request56.getHeaderCaseInsensitive("");
java.lang.String str69 = request56.cookie("");
request56.ignoreContentType = false;
java.util.Map<java.lang.String, java.lang.String> strMap72 = request56.cookies();
boolean boolean73 = request56.followRedirects();
org.jsoup.helper.HttpConnection.KeyVal keyVal74 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal74.key = "hi!";
java.lang.String str77 = keyVal74.key;
org.jsoup.helper.HttpConnection.Request request78 = request56.data((org.jsoup.Connection.KeyVal) keyVal74);
org.jsoup.Connection.Method method79 = request78.method();
org.jsoup.Connection connection80 = httpConnection46.method(method79);
org.jsoup.Connection.Response response81 = response1.method(method79);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str28);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection55);
org.junit.Assert.assertTrue("'" + method57 + "' != '" + org.jsoup.Connection.Method.GET + "'", method57.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean58 + "' != '" + false + "'", boolean58 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean62 + "' != '" + false + "'", boolean62 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str69);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean73 + "' != '" + true + "'", boolean73 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str77 + "' != '" + "hi!" + "'", str77.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request78);
org.junit.Assert.assertTrue("'" + method79 + "' != '" + org.jsoup.Connection.Method.GET + "'", method79.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response81);
}
@Test
public void test0865() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0865");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection1 = org.jsoup.helper.HttpConnection.connect("null=");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Malformed URL: null=");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
}
@Test
public void test0866() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0866");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
org.jsoup.Connection.Request request8 = request0.removeCookie("null=null=");
boolean boolean9 = request0.ignoreContentType;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
}
@Test
public void test0867() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0867");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
org.jsoup.Connection.Request request7 = response1.req;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = response1.scanHeaders("hi!=null");
java.util.Map<java.lang.String, java.lang.String> strMap10 = response1.headers();
org.jsoup.Connection.Response response13 = response1.header("null=null=", "hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response13);
}
@Test
public void test0868() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0868");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.parser.Parser parser13 = request0.parser;
org.jsoup.Connection.Request request15 = request0.removeHeader("null=null=hi!");
org.jsoup.Connection.Request request18 = request0.header("null=null=", "");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
}
@Test
public void test0869() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0869");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
org.jsoup.Connection.Request request8 = request0.followRedirects(false);
java.lang.String str10 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
java.util.Map<java.lang.String, java.lang.String> strMap13 = request11.headers();
request11.followRedirects = false;
boolean boolean16 = request11.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request18 = request11.timeout((int) ' ');
java.lang.String str20 = request18.cookie("hi!");
java.lang.String str22 = request18.header("null=null");
request18.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser30 = request25.parser;
request18.parser = parser30;
request0.parser = parser30;
int int33 = request0.timeoutMilliseconds;
org.jsoup.Connection.Request request36 = request0.cookie("null=null=null=hi!", "hi!=null");
org.jsoup.Connection.Request request38 = request0.removeHeader("null=null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int33 + "' != '" + 3000 + "'", int33 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
}
@Test
public void test0870() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0870");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
org.jsoup.helper.HttpConnection.KeyVal keyVal8 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "");
org.jsoup.helper.HttpConnection.Request request9 = request0.data((org.jsoup.Connection.KeyVal) keyVal8);
org.jsoup.Connection.Request request12 = request9.header("null=hi!", "");
org.jsoup.Connection.Request request15 = request9.header("null=null=hi!", "hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
}
@Test
public void test0871() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0871");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.Connection connection8 = httpConnection0.userAgent("null=null");
org.jsoup.helper.HttpConnection.Response response9 = null;
org.jsoup.helper.HttpConnection.Response response10 = new org.jsoup.helper.HttpConnection.Response(response9);
int int11 = response10.statusCode();
int int12 = response10.numRedirects;
response10.charset = "";
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
java.util.Map<java.lang.String, java.lang.String> strMap17 = request15.headers();
request15.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
boolean boolean22 = request20.ignoreHttpErrors();
org.jsoup.Connection.Request request25 = request20.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.followRedirects = false;
boolean boolean31 = request26.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request33 = request26.timeout((int) ' ');
java.lang.String str35 = request33.cookie("hi!");
java.lang.String str37 = request33.header("null=null");
request33.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request40 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method41 = request40.method();
java.util.Map<java.lang.String, java.lang.String> strMap42 = request40.headers();
request40.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser45 = request40.parser;
request33.parser = parser45;
org.jsoup.helper.HttpConnection.Request request47 = request20.parser(parser45);
org.jsoup.helper.HttpConnection.Request request48 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method49 = request48.method();
org.jsoup.Connection.Request request50 = request47.method(method49);
org.jsoup.Connection.Request request51 = request15.method(method49);
org.jsoup.Connection.Response response52 = response10.method(method49);
org.jsoup.Connection.Request request53 = response10.req;
response10.statusCode = (byte) 10;
java.util.Map<java.lang.String, java.lang.String> strMap56 = response10.headers();
org.jsoup.Connection connection57 = httpConnection0.cookies(strMap56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 0 + "'", int11 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap17);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
org.junit.Assert.assertTrue("'" + method41 + "' != '" + org.jsoup.Connection.Method.GET + "'", method41.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
org.junit.Assert.assertTrue("'" + method49 + "' != '" + org.jsoup.Connection.Method.GET + "'", method49.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
}
@Test
public void test0872() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0872");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
java.net.URL uRL7 = request0.url();
boolean boolean8 = request0.ignoreContentType();
request0.maxBodySizeBytes = (-1);
java.lang.String str12 = request0.header("null=null=hi!");
org.jsoup.Connection.Request request14 = request0.removeCookie("null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
}
@Test
public void test0873() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0873");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str6 = response1.getHeaderCaseInsensitive("null=null");
java.lang.String str7 = response1.statusMessage;
java.nio.ByteBuffer byteBuffer8 = null;
response1.byteData = byteBuffer8;
boolean boolean10 = response1.executed;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
}
@Test
public void test0874() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0874");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
int int12 = request7.maxBodySize();
java.lang.String str14 = request7.header("hi!");
java.util.Map<java.lang.String, java.lang.String> strMap15 = request7.headers();
int int16 = request7.timeoutMilliseconds;
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
boolean boolean23 = request17.ignoreContentType;
request17.ignoreHttpErrors = true;
java.net.URL uRL26 = request17.url();
org.jsoup.Connection.Request request28 = request17.ignoreContentType(false);
request17.ignoreHttpErrors = true;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection31 = request17.data();
request7.data = keyValCollection31;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int16 + "' != '" + 32 + "'", int16 == 32);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean23 + "' != '" + false + "'", boolean23 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection31);
}
@Test
public void test0875() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0875");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
org.jsoup.Connection.Request request12 = request7.cookie("null=null", "null=null=null=hi!");
boolean boolean14 = request7.hasCookie("null=null=null=hi!");
int int15 = request7.timeoutMilliseconds;
boolean boolean16 = request7.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection17 = request7.data;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 32 + "'", int15 == 32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection17);
}
@Test
public void test0876() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0876");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
org.jsoup.helper.HttpConnection.Response response5 = new org.jsoup.helper.HttpConnection.Response(response1);
response5.statusCode = ' ';
org.jsoup.Connection.Response response10 = response5.cookie("null=null=null=hi!", "hi!=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response10);
}
@Test
public void test0877() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0877");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
org.jsoup.helper.HttpConnection.Response response5 = new org.jsoup.helper.HttpConnection.Response(response1);
org.jsoup.Connection.Request request6 = response5.req;
java.nio.ByteBuffer byteBuffer7 = response5.byteData;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(byteBuffer7);
}
@Test
public void test0878() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0878");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
org.jsoup.Connection.Request request8 = request0.followRedirects(false);
java.lang.String str10 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
boolean boolean13 = request11.followRedirects;
org.jsoup.Connection.Request request15 = request11.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap16 = request11.headers();
boolean boolean17 = request11.ignoreContentType;
request11.maxBodySizeBytes = (short) 100;
org.jsoup.parser.Parser parser20 = request11.parser;
org.jsoup.helper.HttpConnection.Request request21 = request0.parser(parser20);
java.lang.String str23 = request0.header("hi!=null");
boolean boolean24 = request0.followRedirects();
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
boolean boolean27 = request25.followRedirects;
org.jsoup.Connection.Request request29 = request25.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap30 = request25.cookies();
boolean boolean32 = request25.hasCookie("");
org.jsoup.helper.HttpConnection.KeyVal keyVal33 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str34 = keyVal33.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal36 = keyVal33.value("hi!");
java.lang.String str37 = keyVal33.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal39 = keyVal33.value("hi!");
java.lang.String str40 = keyVal33.key();
org.jsoup.helper.HttpConnection.Request request41 = request25.data((org.jsoup.Connection.KeyVal) keyVal33);
org.jsoup.helper.HttpConnection.Request request42 = request0.data((org.jsoup.Connection.KeyVal) keyVal33);
int int43 = request0.maxBodySize();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + true + "'", boolean13 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + false + "'", boolean24 == false);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + true + "'", boolean27 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int43 + "' != '" + 1048576 + "'", int43 == 1048576);
}
@Test
public void test0879() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0879");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
org.jsoup.Connection connection11 = httpConnection8.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request12 = httpConnection8.req;
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
java.util.Map<java.lang.String, java.lang.String> strMap15 = request13.headers();
request13.followRedirects = false;
boolean boolean18 = request13.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request20 = request13.timeout((int) ' ');
java.lang.String str22 = request20.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection23 = request20.data();
org.jsoup.Connection connection24 = httpConnection8.data(keyValCollection23);
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
boolean boolean27 = request25.followRedirects;
org.jsoup.Connection.Request request29 = request25.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap30 = request25.headers();
boolean boolean31 = request25.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
java.util.Map<java.lang.String, java.lang.String> strMap34 = request32.headers();
request32.followRedirects = false;
boolean boolean37 = request32.ignoreHttpErrors;
org.jsoup.Connection.Method method38 = request32.method();
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
boolean boolean41 = request39.followRedirects;
org.jsoup.Connection.Request request43 = request39.followRedirects(true);
java.lang.String str45 = request39.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request46 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method47 = request46.method();
org.jsoup.Connection.Request request48 = request39.method(method47);
org.jsoup.Connection.Request request49 = request32.method(method47);
org.jsoup.Connection.Request request50 = request25.method(method47);
org.jsoup.Connection connection51 = httpConnection8.method(method47);
org.jsoup.Connection.Request request52 = request0.method(method47);
org.jsoup.helper.HttpConnection.Request request54 = request0.timeout((int) (short) 0);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean18 + "' != '" + false + "'", boolean18 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + true + "'", boolean27 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean41 + "' != '" + true + "'", boolean41 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str45);
org.junit.Assert.assertTrue("'" + method47 + "' != '" + org.jsoup.Connection.Method.GET + "'", method47.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request48);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request54);
}
@Test
public void test0880() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0880");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.lang.String str2 = response1.statusMessage();
response1.contentType = "null=";
java.lang.String str5 = response1.contentType;
java.lang.String str7 = response1.header("hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str5 + "' != '" + "null=" + "'", str5.equals("null="));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
}
@Test
public void test0881() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0881");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request5 = request0.removeCookie("");
int int6 = request0.maxBodySize();
org.jsoup.Connection.Request request8 = request0.followRedirects(false);
java.lang.String str10 = request0.getHeaderCaseInsensitive("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
java.util.Map<java.lang.String, java.lang.String> strMap13 = request11.headers();
request11.followRedirects = false;
boolean boolean16 = request11.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request18 = request11.timeout((int) ' ');
java.lang.String str20 = request18.cookie("hi!");
java.lang.String str22 = request18.header("null=null");
request18.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser30 = request25.parser;
request18.parser = parser30;
request0.parser = parser30;
org.jsoup.helper.HttpConnection.Response response33 = null;
org.jsoup.helper.HttpConnection.Response response34 = new org.jsoup.helper.HttpConnection.Response(response33);
int int35 = response34.statusCode();
int int36 = response34.numRedirects;
response34.charset = "";
org.jsoup.helper.HttpConnection.Request request39 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method40 = request39.method();
java.util.Map<java.lang.String, java.lang.String> strMap41 = request39.headers();
request39.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request44 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method45 = request44.method();
boolean boolean46 = request44.ignoreHttpErrors();
org.jsoup.Connection.Request request49 = request44.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
java.util.Map<java.lang.String, java.lang.String> strMap52 = request50.headers();
request50.followRedirects = false;
boolean boolean55 = request50.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request57 = request50.timeout((int) ' ');
java.lang.String str59 = request57.cookie("hi!");
java.lang.String str61 = request57.header("null=null");
request57.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request64 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method65 = request64.method();
java.util.Map<java.lang.String, java.lang.String> strMap66 = request64.headers();
request64.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser69 = request64.parser;
request57.parser = parser69;
org.jsoup.helper.HttpConnection.Request request71 = request44.parser(parser69);
org.jsoup.helper.HttpConnection.Request request72 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method73 = request72.method();
org.jsoup.Connection.Request request74 = request71.method(method73);
org.jsoup.Connection.Request request75 = request39.method(method73);
org.jsoup.Connection.Response response76 = response34.method(method73);
org.jsoup.Connection.Request request77 = response34.req;
response34.statusCode = (byte) 10;
response34.charset = "null=";
java.lang.String str83 = response34.getHeaderCaseInsensitive("null=null");
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response84 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request0, response34);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 1048576 + "'", int6 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int35 + "' != '" + 0 + "'", int35 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int36 + "' != '" + 0 + "'", int36 == 0);
org.junit.Assert.assertTrue("'" + method40 + "' != '" + org.jsoup.Connection.Method.GET + "'", method40.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap41);
org.junit.Assert.assertTrue("'" + method45 + "' != '" + org.jsoup.Connection.Method.GET + "'", method45.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean46 + "' != '" + false + "'", boolean46 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request49);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean55 + "' != '" + false + "'", boolean55 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str61);
org.junit.Assert.assertTrue("'" + method65 + "' != '" + org.jsoup.Connection.Method.GET + "'", method65.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap66);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser69);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request71);
org.junit.Assert.assertTrue("'" + method73 + "' != '" + org.jsoup.Connection.Method.GET + "'", method73.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str83);
}
@Test
public void test0882() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0882");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection10 = request7.data();
java.lang.String str12 = request7.header("hi!");
org.jsoup.Connection.Request request15 = request7.header("null=null=hi!", "");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = request7.scanHeaders("null=null=null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap18 = request7.headers();
java.lang.String str20 = request7.header("hi!=null=hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
}
@Test
public void test0883() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0883");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = new org.jsoup.helper.HttpConnection.KeyVal("hi!=null", "null=null=null=hi!=hi!");
}
@Test
public void test0884() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0884");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
org.jsoup.Connection.Request request11 = request6.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
java.util.Map<java.lang.String, java.lang.String> strMap14 = request12.headers();
request12.followRedirects = false;
boolean boolean17 = request12.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request19 = request12.timeout((int) ' ');
java.lang.String str21 = request19.cookie("hi!");
java.lang.String str23 = request19.header("null=null");
request19.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser31 = request26.parser;
request19.parser = parser31;
org.jsoup.helper.HttpConnection.Request request33 = request6.parser(parser31);
org.jsoup.Connection connection34 = httpConnection0.request((org.jsoup.Connection.Request) request33);
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection35 = request33.data;
java.util.Map<java.lang.String, java.lang.String> strMap36 = request33.headers();
java.util.Map<java.lang.String, java.lang.String> strMap37 = request33.cookies();
boolean boolean39 = request33.hasHeader("null=null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + false + "'", boolean17 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str23);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean39 + "' != '" + false + "'", boolean39 == false);
}
@Test
public void test0885() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0885");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection6 = request0.data();
boolean boolean7 = request0.ignoreHttpErrors;
request0.ignoreContentType = true;
java.lang.String str11 = request0.header("hi!=");
java.util.Map<java.lang.String, java.lang.String> strMap12 = request0.cookies();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
}
@Test
public void test0886() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0886");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
java.lang.String str7 = response1.statusMessage;
response1.contentType = "null=null=hi!";
java.nio.ByteBuffer byteBuffer10 = response1.byteData;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry12 = response1.scanHeaders("null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(byteBuffer10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry12);
}
@Test
public void test0887() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0887");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request7.headers();
org.jsoup.Connection connection9 = httpConnection0.request((org.jsoup.Connection.Request) request7);
org.jsoup.Connection.Request request12 = request7.header("hi!=null", "null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
}
@Test
public void test0888() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0888");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request7.headers();
org.jsoup.Connection connection9 = httpConnection0.request((org.jsoup.Connection.Request) request7);
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
org.jsoup.helper.HttpConnection.Request request12 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method13 = request12.method();
boolean boolean14 = request12.followRedirects;
org.jsoup.Connection.Request request16 = request12.followRedirects(true);
java.lang.String str18 = request12.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request19 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method20 = request19.method();
org.jsoup.Connection.Request request21 = request12.method(method20);
org.jsoup.Connection.Request request22 = request10.method(method20);
org.jsoup.Connection.Request request23 = request7.method(method20);
org.jsoup.helper.HttpConnection.Response response24 = null;
org.jsoup.helper.HttpConnection.Response response25 = new org.jsoup.helper.HttpConnection.Response(response24);
int int26 = response25.numRedirects;
response25.charset = "hi!=null";
java.lang.String str30 = response25.getHeaderCaseInsensitive("null=null");
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response31 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request7, response25);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + true + "'", boolean14 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str18);
org.junit.Assert.assertTrue("'" + method20 + "' != '" + org.jsoup.Connection.Method.GET + "'", method20.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int26 + "' != '" + 0 + "'", int26 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str30);
}
@Test
public void test0889() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0889");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = response1.scanHeaders("null=");
org.jsoup.Connection.Response response20 = response1.header("hi!", "hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response20);
}
@Test
public void test0890() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0890");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
boolean boolean5 = response1.executed;
response1.executed = true;
org.jsoup.Connection.Method method8 = response1.method();
org.jsoup.Connection.Request request9 = response1.req;
response1.charset = "hi!=null";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request9);
}
@Test
public void test0891() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0891");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request4 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method5 = request4.method();
java.util.Map<java.lang.String, java.lang.String> strMap6 = request4.headers();
request4.followRedirects = false;
boolean boolean9 = request4.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request11 = request4.timeout((int) ' ');
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry13 = request4.scanHeaders("null=null");
java.util.Map<java.lang.String, java.lang.String> strMap14 = request4.headers();
httpConnection0.req = request4;
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
org.junit.Assert.assertTrue("'" + method5 + "' != '" + org.jsoup.Connection.Method.GET + "'", method5.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
}
@Test
public void test0892() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0892");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str6 = response1.cookie("null=null=null=hi!");
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document7 = response1.parse();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before parsing response");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
}
@Test
public void test0893() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0893");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!=", "hi!=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = keyVal2.key("null=null=hi!");
java.lang.String str5 = keyVal2.value();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = keyVal2.value("null=null");
java.lang.String str8 = keyVal7.key();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str5 + "' != '" + "hi!=null" + "'", str5.equals("hi!=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str8 + "' != '" + "null=null=hi!" + "'", str8.equals("null=null=hi!"));
}
@Test
public void test0894() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0894");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.followRedirects();
org.jsoup.Connection.Request request10 = request7.maxBodySize(0);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
}
@Test
public void test0895() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0895");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Request request18 = httpConnection0.request();
org.jsoup.Connection.Request request19 = null;
org.jsoup.Connection connection20 = httpConnection0.request(request19);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection23 = httpConnection0.header("null=null=null=hi!=hi!", "hi!=");
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
}
@Test
public void test0896() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0896");
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection1 = org.jsoup.helper.HttpConnection.connect("null=null");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Malformed URL: null=null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
}
@Test
public void test0897() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0897");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
org.jsoup.Connection.Request request16 = request0.removeCookie("");
java.lang.String str17 = org.jsoup.helper.HttpConnection.Response.getRequestCookieString((org.jsoup.Connection.Request) request0);
int int18 = request0.timeout();
int int19 = request0.timeout();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 3000 + "'", int18 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int19 + "' != '" + 3000 + "'", int19 == 3000);
}
@Test
public void test0898() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0898");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
keyVal2.key = "";
keyVal2.key = "null=";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
}
@Test
public void test0899() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0899");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
boolean boolean9 = request0.hasHeader("null=hi!");
org.jsoup.Connection.Request request11 = request0.removeCookie("null=null");
request0.maxBodySizeBytes = (short) -1;
java.net.URL uRL14 = request0.url();
int int15 = request0.maxBodySize();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int15 + "' != '" + (-1) + "'", int15 == (-1));
}
@Test
public void test0900() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0900");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request3 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method4 = request3.method();
java.util.Map<java.lang.String, java.lang.String> strMap5 = request3.headers();
request3.followRedirects = false;
boolean boolean9 = request3.hasCookie("null=null");
java.lang.String str11 = request3.getHeaderCaseInsensitive("null=hi!");
org.jsoup.Connection connection12 = httpConnection0.request((org.jsoup.Connection.Request) request3);
org.jsoup.Connection connection15 = httpConnection0.data("null=hi!", "");
org.jsoup.Connection connection18 = httpConnection0.data("null=null", "null=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
org.junit.Assert.assertTrue("'" + method4 + "' != '" + org.jsoup.Connection.Method.GET + "'", method4.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection18);
}
@Test
public void test0901() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0901");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.util.Map<java.lang.String, java.lang.String> strMap7 = response1.headers();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request8.headers();
request8.followRedirects = false;
boolean boolean13 = request8.ignoreHttpErrors;
org.jsoup.Connection.Method method14 = request8.method();
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
boolean boolean17 = request15.followRedirects;
org.jsoup.Connection.Request request19 = request15.followRedirects(true);
java.lang.String str21 = request15.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request22 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method23 = request22.method();
org.jsoup.Connection.Request request24 = request15.method(method23);
org.jsoup.Connection.Request request25 = request8.method(method23);
org.jsoup.Connection.Response response26 = response1.method(method23);
response1.contentType = "";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str21);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response26);
}
@Test
public void test0902() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0902");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
java.util.Map<java.lang.String, java.lang.String> strMap8 = request6.headers();
request6.followRedirects = false;
boolean boolean11 = request6.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request13 = request6.timeout((int) ' ');
java.lang.String str15 = request13.cookie("hi!");
java.lang.String str17 = request13.header("null=null");
request13.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
java.util.Map<java.lang.String, java.lang.String> strMap22 = request20.headers();
request20.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser25 = request20.parser;
request13.parser = parser25;
org.jsoup.helper.HttpConnection.Request request27 = request0.parser(parser25);
boolean boolean28 = request0.ignoreHttpErrors();
org.jsoup.helper.HttpConnection httpConnection29 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response30 = httpConnection29.response();
org.jsoup.Connection connection32 = httpConnection29.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection33 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection36 = httpConnection33.data("hi!", "hi!");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
int int40 = request37.timeout();
org.jsoup.parser.Parser parser41 = request37.parser();
org.jsoup.Connection connection42 = httpConnection33.parser(parser41);
org.jsoup.Connection connection43 = httpConnection29.parser(parser41);
org.jsoup.helper.HttpConnection.Request request44 = request0.parser(parser41);
org.jsoup.Connection.Request request47 = request44.header("hi!=null", "null=null=null=hi!");
org.jsoup.helper.HttpConnection.Response response48 = null;
org.jsoup.helper.HttpConnection.Response response49 = new org.jsoup.helper.HttpConnection.Response(response48);
int int50 = response49.statusCode();
int int51 = response49.numRedirects;
response49.charset = "";
org.jsoup.helper.HttpConnection.Request request54 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method55 = request54.method();
java.util.Map<java.lang.String, java.lang.String> strMap56 = request54.headers();
request54.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request59 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method60 = request59.method();
boolean boolean61 = request59.ignoreHttpErrors();
org.jsoup.Connection.Request request64 = request59.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request65 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method66 = request65.method();
java.util.Map<java.lang.String, java.lang.String> strMap67 = request65.headers();
request65.followRedirects = false;
boolean boolean70 = request65.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request72 = request65.timeout((int) ' ');
java.lang.String str74 = request72.cookie("hi!");
java.lang.String str76 = request72.header("null=null");
request72.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request79 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method80 = request79.method();
java.util.Map<java.lang.String, java.lang.String> strMap81 = request79.headers();
request79.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser84 = request79.parser;
request72.parser = parser84;
org.jsoup.helper.HttpConnection.Request request86 = request59.parser(parser84);
org.jsoup.helper.HttpConnection.Request request87 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method88 = request87.method();
org.jsoup.Connection.Request request89 = request86.method(method88);
org.jsoup.Connection.Request request90 = request54.method(method88);
org.jsoup.Connection.Response response91 = response49.method(method88);
org.jsoup.Connection.Request request92 = response49.req;
response49.statusCode = (byte) 10;
java.util.Map<java.lang.String, java.lang.String> strMap95 = response49.headers();
response49.executed = true;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response98 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request44, response49);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int40 + "' != '" + 3000 + "'", int40 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int50 + "' != '" + 0 + "'", int50 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int51 + "' != '" + 0 + "'", int51 == 0);
org.junit.Assert.assertTrue("'" + method55 + "' != '" + org.jsoup.Connection.Method.GET + "'", method55.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap56);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean61 + "' != '" + false + "'", boolean61 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request64);
org.junit.Assert.assertTrue("'" + method66 + "' != '" + org.jsoup.Connection.Method.GET + "'", method66.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean70 + "' != '" + false + "'", boolean70 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request72);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str76);
org.junit.Assert.assertTrue("'" + method80 + "' != '" + org.jsoup.Connection.Method.GET + "'", method80.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap81);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser84);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request86);
org.junit.Assert.assertTrue("'" + method88 + "' != '" + org.jsoup.Connection.Method.GET + "'", method88.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request89);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request90);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response91);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request92);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap95);
}
@Test
public void test0903() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0903");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.helper.HttpConnection.Response response19 = null;
org.jsoup.helper.HttpConnection.Response response20 = new org.jsoup.helper.HttpConnection.Response(response19);
int int21 = response20.statusCode();
int int22 = response20.numRedirects;
response20.charset = "";
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request30 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method31 = request30.method();
boolean boolean32 = request30.ignoreHttpErrors();
org.jsoup.Connection.Request request35 = request30.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request36 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method37 = request36.method();
java.util.Map<java.lang.String, java.lang.String> strMap38 = request36.headers();
request36.followRedirects = false;
boolean boolean41 = request36.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request43 = request36.timeout((int) ' ');
java.lang.String str45 = request43.cookie("hi!");
java.lang.String str47 = request43.header("null=null");
request43.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
java.util.Map<java.lang.String, java.lang.String> strMap52 = request50.headers();
request50.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser55 = request50.parser;
request43.parser = parser55;
org.jsoup.helper.HttpConnection.Request request57 = request30.parser(parser55);
org.jsoup.helper.HttpConnection.Request request58 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method59 = request58.method();
org.jsoup.Connection.Request request60 = request57.method(method59);
org.jsoup.Connection.Request request61 = request25.method(method59);
org.jsoup.Connection.Response response62 = response20.method(method59);
org.jsoup.Connection.Request request63 = request18.method(method59);
request18.ignoreContentType = true;
httpConnection0.req = request18;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int21 + "' != '" + 0 + "'", int21 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 0 + "'", int22 == 0);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
org.junit.Assert.assertTrue("'" + method31 + "' != '" + org.jsoup.Connection.Method.GET + "'", method31.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
org.junit.Assert.assertTrue("'" + method37 + "' != '" + org.jsoup.Connection.Method.GET + "'", method37.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean41 + "' != '" + false + "'", boolean41 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str47);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request57);
org.junit.Assert.assertTrue("'" + method59 + "' != '" + org.jsoup.Connection.Method.GET + "'", method59.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request63);
}
@Test
public void test0904() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0904");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.numRedirects;
response1.charset = "hi!=null";
java.lang.String str6 = response1.getHeaderCaseInsensitive("null=null");
java.lang.String str7 = response1.statusMessage;
java.util.Map<java.lang.String, java.lang.String> strMap8 = response1.headers();
org.jsoup.Connection.Response response11 = response1.header("null=", "");
org.jsoup.Connection.Response response14 = response1.header("null=null=null=hi!", "hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response14);
}
@Test
public void test0905() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0905");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
boolean boolean10 = request7.ignoreContentType();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
}
@Test
public void test0906() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0906");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser5 = request0.parser;
org.jsoup.Connection.Request request7 = request0.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap8 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
int int10 = request0.timeoutMilliseconds;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 3000 + "'", int10 == 3000);
}
@Test
public void test0907() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0907");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("");
org.jsoup.helper.HttpConnection.KeyVal keyVal8 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str9 = keyVal8.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal11 = keyVal8.value("hi!");
java.lang.String str12 = keyVal8.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal14 = keyVal8.value("hi!");
java.lang.String str15 = keyVal8.key();
org.jsoup.helper.HttpConnection.Request request16 = request0.data((org.jsoup.Connection.KeyVal) keyVal8);
request16.ignoreContentType = true;
boolean boolean19 = request16.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request21 = request16.timeout(32);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request16.headers();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
}
@Test
public void test0908() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0908");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
java.net.URL uRL7 = request0.url();
org.jsoup.Connection.Request request9 = request0.maxBodySize((int) 'a');
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
}
@Test
public void test0909() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0909");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = response1.scanHeaders("hi!=");
int int18 = response1.numRedirects;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry20 = response1.scanHeaders("null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 0 + "'", int18 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry20);
}
@Test
public void test0910() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0910");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Request request4 = null;
httpConnection0.req = request4;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
boolean boolean8 = request6.ignoreHttpErrors();
boolean boolean10 = request6.hasCookie("null=null");
org.jsoup.Connection connection11 = httpConnection0.request((org.jsoup.Connection.Request) request6);
java.net.URL uRL12 = request6.url();
int int13 = request6.maxBodySize();
request6.ignoreHttpErrors = false;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 1048576 + "'", int13 == 1048576);
}
@Test
public void test0911() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0911");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
boolean boolean4 = request0.hasCookie("null=hi!");
request0.timeoutMilliseconds = (byte) -1;
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str8 = keyVal7.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal7.value("hi!");
java.lang.String str11 = keyVal7.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = keyVal7.value("hi!");
org.jsoup.helper.HttpConnection.Request request14 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
java.lang.String str15 = keyVal13.key();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
}
@Test
public void test0912() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0912");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
int int3 = request0.timeout();
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
org.jsoup.Connection connection7 = httpConnection4.maxBodySize((int) (short) 0);
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
httpConnection4.res = response9;
org.jsoup.Connection connection13 = httpConnection4.header("hi!", "");
org.jsoup.helper.HttpConnection.Request request14 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method15 = request14.method();
boolean boolean16 = request14.followRedirects;
org.jsoup.Connection.Request request18 = request14.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap19 = request14.headers();
boolean boolean20 = request14.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request21 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method22 = request21.method();
java.util.Map<java.lang.String, java.lang.String> strMap23 = request21.headers();
request21.followRedirects = false;
boolean boolean26 = request21.ignoreHttpErrors;
org.jsoup.Connection.Method method27 = request21.method();
org.jsoup.helper.HttpConnection.Request request28 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method29 = request28.method();
boolean boolean30 = request28.followRedirects;
org.jsoup.Connection.Request request32 = request28.followRedirects(true);
java.lang.String str34 = request28.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request35 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method36 = request35.method();
org.jsoup.Connection.Request request37 = request28.method(method36);
org.jsoup.Connection.Request request38 = request21.method(method36);
org.jsoup.Connection.Request request39 = request14.method(method36);
org.jsoup.Connection.Request request41 = request14.removeHeader("hi!=null");
httpConnection4.req = request14;
org.jsoup.parser.Parser parser43 = request14.parser;
request0.parser = parser43;
int int45 = request0.maxBodySizeBytes;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3000 + "'", int3 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
org.junit.Assert.assertTrue("'" + method15 + "' != '" + org.jsoup.Connection.Method.GET + "'", method15.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + true + "'", boolean16 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
org.junit.Assert.assertTrue("'" + method22 + "' != '" + org.jsoup.Connection.Method.GET + "'", method22.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + false + "'", boolean26 == false);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method29 + "' != '" + org.jsoup.Connection.Method.GET + "'", method29.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean30 + "' != '" + true + "'", boolean30 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str34);
org.junit.Assert.assertTrue("'" + method36 + "' != '" + org.jsoup.Connection.Method.GET + "'", method36.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int45 + "' != '" + 1048576 + "'", int45 == 1048576);
}
@Test
public void test0913() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0913");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
org.jsoup.Connection.Request request5 = response1.req;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request5);
}
@Test
public void test0914() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0914");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.Connection connection8 = httpConnection0.userAgent("null=null");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
boolean boolean11 = request9.ignoreHttpErrors();
org.jsoup.Connection.Request request14 = request9.cookie("hi!", "");
boolean boolean15 = request9.ignoreContentType;
org.jsoup.Connection.Request request18 = request9.cookie("null=hi!", "hi!");
org.jsoup.Connection connection19 = httpConnection0.request((org.jsoup.Connection.Request) request9);
boolean boolean20 = request9.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.KeyVal keyVal23 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
java.lang.String str24 = keyVal23.key();
org.jsoup.helper.HttpConnection.Request request25 = request9.data((org.jsoup.Connection.KeyVal) keyVal23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str24 + "' != '" + "hi!" + "'", str24.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
}
@Test
public void test0915() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0915");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.parser.Parser parser13 = request0.parser;
java.lang.String str15 = request0.cookie("null=");
java.lang.String str17 = request0.getHeaderCaseInsensitive("null=null=null=hi!=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
}
@Test
public void test0916() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0916");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
boolean boolean11 = request7.hasCookie("null=hi!");
org.jsoup.helper.HttpConnection.Response response12 = null;
org.jsoup.helper.HttpConnection.Response response13 = new org.jsoup.helper.HttpConnection.Response(response12);
int int14 = response13.statusCode();
int int15 = response13.numRedirects;
response13.charset = "";
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
org.jsoup.Connection.Request request21 = request18.ignoreContentType(false);
org.jsoup.Connection.Request request23 = request18.removeCookie("");
int int24 = request18.maxBodySize();
org.jsoup.Connection.Request request26 = request18.followRedirects(false);
response13.req = request18;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry29 = response13.scanHeaders("hi!=");
int int30 = response13.numRedirects;
org.jsoup.Connection.Response response32 = response13.removeHeader("null=");
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response33 = org.jsoup.helper.HttpConnection.Response.execute((org.jsoup.Connection.Request) request7, response13);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 0 + "'", int14 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int15 + "' != '" + 0 + "'", int15 == 0);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int24 + "' != '" + 1048576 + "'", int24 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 0 + "'", int30 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response32);
}
@Test
public void test0917() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0917");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal0.key = "hi!";
java.lang.String str3 = keyVal0.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal5 = keyVal0.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = keyVal5.key("null=hi!");
java.lang.String str8 = keyVal5.key();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "hi!" + "'", str3.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str8 + "' != '" + "null=hi!" + "'", str8.equals("null=hi!"));
}
@Test
public void test0918() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0918");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.util.Map<java.lang.String, java.lang.String> strMap7 = response1.headers();
response1.contentType = "null=null=";
java.util.Map<java.lang.String, java.lang.String> strMap10 = response1.headers();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
}
@Test
public void test0919() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0919");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request4 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
request5.followRedirects = false;
boolean boolean10 = request5.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request12 = request5.timeout((int) ' ');
java.lang.String str14 = request12.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request12.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
request17.timeoutMilliseconds = 307;
org.jsoup.parser.Parser parser25 = request17.parser();
org.jsoup.Connection connection26 = httpConnection0.parser(parser25);
org.jsoup.Connection connection29 = httpConnection0.data("null=null", "null=null");
org.jsoup.Connection.Request request30 = httpConnection0.request();
org.jsoup.Connection connection32 = httpConnection0.userAgent("null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
}
@Test
public void test0920() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0920");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.headers();
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str5 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = keyVal4.value("hi!");
java.lang.String str8 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal4.value("hi!");
java.lang.String str11 = keyVal4.key();
org.jsoup.helper.HttpConnection.Request request12 = request0.data((org.jsoup.Connection.KeyVal) keyVal4);
java.net.URL uRL13 = request12.url();
boolean boolean14 = request12.ignoreContentType;
java.lang.String str16 = request12.header("hi!");
int int17 = request12.maxBodySizeBytes;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 1048576 + "'", int17 == 1048576);
}
@Test
public void test0921() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0921");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.lang.String str14 = request8.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
org.jsoup.Connection.Request request17 = request8.method(method16);
org.jsoup.Connection.Request request18 = request6.method(method16);
boolean boolean20 = request6.hasHeader("hi!");
org.jsoup.Connection.Request request22 = request6.removeCookie("");
httpConnection0.req = request22;
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request25 = null;
org.jsoup.Connection connection26 = httpConnection24.request(request25);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection connection29 = httpConnection24.response(response28);
httpConnection0.res = response28;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
boolean boolean33 = request31.ignoreHttpErrors();
org.jsoup.Connection.Request request36 = request31.cookie("hi!", "");
org.jsoup.helper.HttpConnection.Request request37 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method38 = request37.method();
java.util.Map<java.lang.String, java.lang.String> strMap39 = request37.headers();
request37.followRedirects = false;
boolean boolean42 = request37.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request44 = request37.timeout((int) ' ');
java.lang.String str46 = request44.cookie("hi!");
java.lang.String str48 = request44.header("null=null");
request44.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request51 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method52 = request51.method();
java.util.Map<java.lang.String, java.lang.String> strMap53 = request51.headers();
request51.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser56 = request51.parser;
request44.parser = parser56;
org.jsoup.helper.HttpConnection.Request request58 = request31.parser(parser56);
org.jsoup.helper.HttpConnection.Request request59 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method60 = request59.method();
org.jsoup.Connection.Request request61 = request58.method(method60);
org.jsoup.Connection connection62 = httpConnection0.method(method60);
org.jsoup.Connection connection65 = httpConnection0.header("null=hi!", "");
org.jsoup.Connection connection68 = httpConnection0.data("null=null", "hi!=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + false + "'", boolean33 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request36);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + false + "'", boolean42 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str46);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str48);
org.junit.Assert.assertTrue("'" + method52 + "' != '" + org.jsoup.Connection.Method.GET + "'", method52.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request58);
org.junit.Assert.assertTrue("'" + method60 + "' != '" + org.jsoup.Connection.Method.GET + "'", method60.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection68);
}
@Test
public void test0922() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0922");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.maxBodySize((int) (short) 1);
org.jsoup.Connection connection6 = httpConnection0.ignoreHttpErrors(false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
}
@Test
public void test0923() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0923");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
int int3 = request0.timeout();
boolean boolean4 = request0.ignoreHttpErrors();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = org.jsoup.helper.HttpConnection.KeyVal.create("null=null=null=hi!", "null=null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = keyVal7.key("hi!=");
keyVal7.value = "";
org.jsoup.helper.HttpConnection.Request request12 = request0.data((org.jsoup.Connection.KeyVal) keyVal7);
org.jsoup.Connection.Request request15 = request0.cookie("null=null=hi!", "hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 3000 + "'", int3 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
}
@Test
public void test0924() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0924");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection19 = httpConnection0.referrer("hi!");
org.jsoup.Connection.Request request20 = httpConnection0.request();
org.jsoup.Connection.Request request21 = httpConnection0.request();
org.jsoup.helper.HttpConnection.Request request22 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method23 = request22.method();
boolean boolean24 = request22.followRedirects;
org.jsoup.Connection.Request request26 = request22.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap27 = request22.headers();
boolean boolean28 = request22.ignoreContentType;
boolean boolean29 = request22.followRedirects();
org.jsoup.helper.HttpConnection.Request request30 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method31 = request30.method();
org.jsoup.Connection.Request request32 = request22.method(method31);
boolean boolean33 = request22.followRedirects();
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection34 = request22.data();
org.jsoup.Connection connection35 = httpConnection0.request((org.jsoup.Connection.Request) request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean24 + "' != '" + true + "'", boolean24 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean28 + "' != '" + false + "'", boolean28 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean29 + "' != '" + true + "'", boolean29 == true);
org.junit.Assert.assertTrue("'" + method31 + "' != '" + org.jsoup.Connection.Method.GET + "'", method31.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + true + "'", boolean33 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection35);
}
@Test
public void test0925() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0925");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
response1.statusCode = (short) -1;
java.util.Map<java.lang.String, java.lang.String> strMap9 = response1.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
boolean boolean17 = request10.followRedirects();
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
org.jsoup.Connection.Request request20 = request10.method(method19);
org.jsoup.Connection.Response response21 = response1.method(method19);
int int22 = response1.numRedirects;
org.jsoup.Connection.Method method23 = response1.method();
java.nio.ByteBuffer byteBuffer24 = null;
response1.byteData = byteBuffer24;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int22 + "' != '" + 0 + "'", int22 == 0);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
}
@Test
public void test0926() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0926");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.maxBodySize((int) (short) 1);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request6 = null;
org.jsoup.Connection connection7 = httpConnection5.request(request6);
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
org.jsoup.Connection.Request request10 = httpConnection8.request();
org.jsoup.Connection connection11 = httpConnection5.request(request10);
org.jsoup.Connection connection14 = httpConnection5.cookie("null=null", "null=null");
org.jsoup.Connection connection16 = httpConnection5.followRedirects(true);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.cookies();
org.jsoup.Connection connection23 = httpConnection5.data(strMap22);
org.jsoup.Connection connection24 = httpConnection0.data(strMap22);
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.followRedirects = false;
java.lang.String str31 = request25.cookie("");
boolean boolean32 = request25.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
java.util.Map<java.lang.String, java.lang.String> strMap35 = request33.headers();
request33.followRedirects = false;
boolean boolean38 = request33.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection39 = request33.data();
request25.data = keyValCollection39;
org.jsoup.helper.HttpConnection.KeyVal keyVal43 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = keyVal43.key("null=null");
org.jsoup.helper.HttpConnection.Request request46 = request25.data((org.jsoup.Connection.KeyVal) keyVal45);
org.jsoup.helper.HttpConnection.Request request47 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method48 = request47.method();
java.util.Map<java.lang.String, java.lang.String> strMap49 = request47.headers();
request47.followRedirects = false;
boolean boolean52 = request47.ignoreHttpErrors;
org.jsoup.Connection.Method method53 = request47.method();
int int54 = request47.maxBodySizeBytes;
org.jsoup.Connection.Method method55 = request47.method();
org.jsoup.Connection.Request request56 = request25.method(method55);
org.jsoup.Connection connection57 = httpConnection0.request((org.jsoup.Connection.Request) request25);
org.jsoup.helper.HttpConnection httpConnection58 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection60 = httpConnection58.followRedirects(false);
org.jsoup.Connection connection62 = httpConnection58.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection63 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response64 = httpConnection63.response();
org.jsoup.helper.HttpConnection httpConnection65 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response66 = httpConnection65.response();
org.jsoup.Connection connection68 = httpConnection65.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection69 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response70 = httpConnection69.response();
httpConnection65.res = response70;
httpConnection63.res = response70;
org.jsoup.Connection connection73 = httpConnection58.response(response70);
org.jsoup.Connection connection75 = httpConnection58.ignoreHttpErrors(false);
org.jsoup.Connection connection77 = httpConnection58.referrer("hi!");
org.jsoup.helper.HttpConnection.Request request78 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method79 = request78.method();
java.util.Map<java.lang.String, java.lang.String> strMap80 = request78.headers();
request78.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser83 = request78.parser;
org.jsoup.Connection connection84 = httpConnection58.parser(parser83);
org.jsoup.Connection connection85 = httpConnection0.parser(parser83);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection.Response response86 = httpConnection0.execute();
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + false + "'", boolean38 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
org.junit.Assert.assertTrue("'" + method48 + "' != '" + org.jsoup.Connection.Method.GET + "'", method48.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + false + "'", boolean52 == false);
org.junit.Assert.assertTrue("'" + method53 + "' != '" + org.jsoup.Connection.Method.GET + "'", method53.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 1048576 + "'", int54 == 1048576);
org.junit.Assert.assertTrue("'" + method55 + "' != '" + org.jsoup.Connection.Method.GET + "'", method55.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response66);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection68);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response70);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection73);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection77);
org.junit.Assert.assertTrue("'" + method79 + "' != '" + org.jsoup.Connection.Method.GET + "'", method79.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser83);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection84);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection85);
}
@Test
public void test0927() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0927");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str7 = response1.cookie("null=null");
java.lang.String str8 = response1.charset;
int int9 = response1.numRedirects;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
}
@Test
public void test0928() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0928");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str14 = keyVal13.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal16 = keyVal13.value("");
java.lang.String str17 = keyVal13.value();
org.jsoup.helper.HttpConnection.Request request18 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
keyVal13.value = "null=null";
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str14 + "' != '" + "null=null" + "'", str14.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str17 + "' != '" + "" + "'", str17.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
}
@Test
public void test0929() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0929");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.helper.HttpConnection.Request request4 = request0.timeout((int) (short) 0);
org.jsoup.Connection.Method method5 = request0.method();
boolean boolean6 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request8 = request0.timeout((int) (byte) 100);
boolean boolean9 = request8.ignoreHttpErrors();
org.jsoup.Connection.Request request11 = request8.removeCookie("hi!=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method5 + "' != '" + org.jsoup.Connection.Method.GET + "'", method5.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
}
@Test
public void test0930() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0930");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
request7.followRedirects = false;
org.jsoup.helper.HttpConnection httpConnection14 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request15 = null;
org.jsoup.Connection connection16 = httpConnection14.request(request15);
org.jsoup.helper.HttpConnection httpConnection17 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response18 = httpConnection17.response();
org.jsoup.Connection.Request request19 = httpConnection17.request();
org.jsoup.Connection connection20 = httpConnection14.request(request19);
org.jsoup.Connection.Request request21 = httpConnection14.req;
org.jsoup.Connection connection23 = httpConnection14.ignoreContentType(true);
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
boolean boolean26 = request24.followRedirects;
org.jsoup.Connection.Request request28 = request24.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap29 = request24.headers();
boolean boolean30 = request24.ignoreContentType;
request24.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap33 = request24.cookies();
httpConnection14.req = request24;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection35 = request24.data;
org.jsoup.Connection.Request request38 = request24.cookie("null=null", "hi!");
int int39 = request24.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request40 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method41 = request40.method();
boolean boolean42 = request40.followRedirects;
org.jsoup.Connection.Request request44 = request40.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap45 = request40.cookies();
boolean boolean47 = request40.hasCookie("null=null");
java.lang.String str49 = request40.cookie("hi!=null");
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
boolean boolean52 = request50.followRedirects;
org.jsoup.Connection.Request request54 = request50.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap55 = request50.headers();
boolean boolean56 = request50.ignoreContentType;
org.jsoup.helper.HttpConnection.Request request57 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method58 = request57.method();
java.util.Map<java.lang.String, java.lang.String> strMap59 = request57.headers();
request57.followRedirects = false;
boolean boolean62 = request57.ignoreHttpErrors;
org.jsoup.Connection.Method method63 = request57.method();
org.jsoup.helper.HttpConnection.Request request64 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method65 = request64.method();
boolean boolean66 = request64.followRedirects;
org.jsoup.Connection.Request request68 = request64.followRedirects(true);
java.lang.String str70 = request64.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request71 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method72 = request71.method();
org.jsoup.Connection.Request request73 = request64.method(method72);
org.jsoup.Connection.Request request74 = request57.method(method72);
org.jsoup.Connection.Request request75 = request50.method(method72);
org.jsoup.Connection.Request request76 = request40.method(method72);
org.jsoup.Connection.Request request77 = request24.method(method72);
org.jsoup.Connection.Request request78 = request7.method(method72);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + true + "'", boolean26 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean30 + "' != '" + false + "'", boolean30 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 1048576 + "'", int39 == 1048576);
org.junit.Assert.assertTrue("'" + method41 + "' != '" + org.jsoup.Connection.Method.GET + "'", method41.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + true + "'", boolean42 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str49);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + true + "'", boolean52 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + false + "'", boolean56 == false);
org.junit.Assert.assertTrue("'" + method58 + "' != '" + org.jsoup.Connection.Method.GET + "'", method58.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean62 + "' != '" + false + "'", boolean62 == false);
org.junit.Assert.assertTrue("'" + method63 + "' != '" + org.jsoup.Connection.Method.GET + "'", method63.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method65 + "' != '" + org.jsoup.Connection.Method.GET + "'", method65.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean66 + "' != '" + true + "'", boolean66 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request68);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str70);
org.junit.Assert.assertTrue("'" + method72 + "' != '" + org.jsoup.Connection.Method.GET + "'", method72.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request73);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request74);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request76);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request78);
}
@Test
public void test0931() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0931");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal0.key = "hi!";
java.lang.String str3 = keyVal0.value;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str3);
}
@Test
public void test0932() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0932");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
java.lang.String str3 = keyVal2.value;
java.lang.String str4 = keyVal2.key();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "null=null" + "'", str3.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str4 + "' != '" + "hi!" + "'", str4.equals("hi!"));
}
@Test
public void test0933() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0933");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.Connection.Method method6 = request0.method();
java.net.URL uRL7 = request0.url();
boolean boolean8 = request0.followRedirects;
org.jsoup.helper.HttpConnection.KeyVal keyVal9 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str10 = keyVal9.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal12 = keyVal9.value("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal14 = keyVal9.key("hi!");
java.lang.String str15 = keyVal9.value;
org.jsoup.helper.HttpConnection.Request request16 = request0.data((org.jsoup.Connection.KeyVal) keyVal9);
java.lang.String str18 = request0.cookie("null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str15 + "' != '" + "hi!" + "'", str15.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str18);
}
@Test
public void test0934() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0934");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str7 = response1.cookie("null=null");
response1.executed = false;
java.util.Map<java.lang.String, java.lang.String> strMap10 = response1.headers();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
}
@Test
public void test0935() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0935");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.ignoreHttpErrors = true;
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
java.lang.String str12 = request0.getHeaderCaseInsensitive("null=null");
org.jsoup.parser.Parser parser13 = request0.parser;
org.jsoup.Connection.Request request15 = request0.ignoreHttpErrors(false);
org.jsoup.Connection.Method method16 = request0.method();
int int17 = request0.maxBodySize();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request15);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int17 + "' != '" + 1048576 + "'", int17 == 1048576);
}
@Test
public void test0936() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0936");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.maxBodySize((int) (short) 1);
org.jsoup.Connection connection6 = httpConnection0.ignoreHttpErrors(true);
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
boolean boolean9 = request7.followRedirects;
org.jsoup.Connection.Request request11 = request7.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap12 = request7.headers();
boolean boolean13 = request7.ignoreContentType;
request7.maxBodySizeBytes = (short) 100;
org.jsoup.parser.Parser parser16 = request7.parser;
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
java.util.Map<java.lang.String, java.lang.String> strMap19 = request17.headers();
request17.followRedirects = false;
boolean boolean22 = request17.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request24 = request17.timeout((int) ' ');
java.lang.String str26 = request24.cookie("hi!");
java.lang.String str28 = request24.header("null=null");
request24.followRedirects = false;
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser36 = request31.parser;
request24.parser = parser36;
org.jsoup.helper.HttpConnection.Request request38 = request7.parser(parser36);
int int39 = request7.timeout();
java.lang.String str41 = request7.cookie("null=hi!");
org.jsoup.Connection connection42 = httpConnection0.request((org.jsoup.Connection.Request) request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + true + "'", boolean9 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + false + "'", boolean22 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str28);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 3000 + "'", int39 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
}
@Test
public void test0937() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0937");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
response1.charset = "hi!=null";
org.jsoup.Connection.Response response6 = response1.removeHeader("hi!=");
java.lang.String str7 = response1.contentType();
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
}
@Test
public void test0938() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0938");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.lang.String str11 = request7.header("null=null");
org.jsoup.Connection.Request request14 = request7.header("null=null=null=hi!", "");
boolean boolean15 = request7.followRedirects;
request7.maxBodySizeBytes = 0;
org.jsoup.helper.HttpConnection.Request request19 = request7.timeout((int) 'a');
int int20 = request7.timeoutMilliseconds;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + false + "'", boolean15 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int20 + "' != '" + 97 + "'", int20 == 97);
}
@Test
public void test0939() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0939");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.lang.String str14 = request8.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
org.jsoup.Connection.Request request17 = request8.method(method16);
org.jsoup.Connection.Request request18 = request6.method(method16);
boolean boolean20 = request6.hasHeader("hi!");
org.jsoup.Connection.Request request22 = request6.removeCookie("");
httpConnection0.req = request22;
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request25 = null;
org.jsoup.Connection connection26 = httpConnection24.request(request25);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection connection29 = httpConnection24.response(response28);
httpConnection0.res = response28;
org.jsoup.Connection connection32 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection34 = httpConnection0.userAgent("null=null");
java.net.URL uRL35 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection36 = httpConnection0.url(uRL35);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
}
@Test
public void test0940() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0940");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.Connection.Request request4 = httpConnection0.req;
org.jsoup.helper.HttpConnection.Request request5 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method6 = request5.method();
java.util.Map<java.lang.String, java.lang.String> strMap7 = request5.headers();
request5.followRedirects = false;
boolean boolean10 = request5.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request12 = request5.timeout((int) ' ');
java.lang.String str14 = request12.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request12.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.headers();
request17.timeoutMilliseconds = 307;
org.jsoup.parser.Parser parser25 = request17.parser();
org.jsoup.Connection connection26 = httpConnection0.parser(parser25);
org.jsoup.Connection connection29 = httpConnection0.data("null=null", "null=null");
org.jsoup.Connection.Request request30 = httpConnection0.request();
java.lang.Class<?> wildcardClass31 = httpConnection0.getClass();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
org.junit.Assert.assertTrue("'" + method6 + "' != '" + org.jsoup.Connection.Method.GET + "'", method6.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request30);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(wildcardClass31);
}
@Test
public void test0941() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0941");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(false);
org.jsoup.Connection.Response response4 = httpConnection0.response();
org.jsoup.Connection.Request request5 = httpConnection0.request();
org.jsoup.helper.HttpConnection httpConnection6 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response7 = httpConnection6.response();
org.jsoup.Connection.Request request8 = httpConnection6.request();
org.jsoup.Connection.Request request9 = httpConnection6.req;
org.jsoup.Connection connection11 = httpConnection6.timeout((int) 'a');
org.jsoup.helper.HttpConnection httpConnection12 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response13 = httpConnection12.response();
org.jsoup.Connection.Request request14 = httpConnection12.request();
org.jsoup.Connection connection16 = httpConnection12.ignoreContentType(true);
org.jsoup.Connection.Request request17 = httpConnection12.request();
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
java.util.Map<java.lang.String, java.lang.String> strMap20 = request18.headers();
org.jsoup.Connection.Method method21 = request18.method();
java.util.Map<java.lang.String, java.lang.String> strMap22 = request18.cookies();
org.jsoup.Connection connection23 = httpConnection12.cookies(strMap22);
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response25 = httpConnection24.response();
org.jsoup.Connection.Request request26 = httpConnection24.request();
org.jsoup.Connection connection28 = httpConnection24.ignoreContentType(true);
org.jsoup.Connection.Request request29 = httpConnection24.request();
org.jsoup.Connection connection31 = httpConnection24.referrer("null=hi!");
org.jsoup.helper.HttpConnection httpConnection32 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request33 = null;
org.jsoup.Connection connection34 = httpConnection32.request(request33);
org.jsoup.helper.HttpConnection httpConnection35 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response36 = httpConnection35.response();
org.jsoup.Connection.Request request37 = httpConnection35.request();
org.jsoup.Connection connection38 = httpConnection32.request(request37);
org.jsoup.helper.HttpConnection httpConnection39 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection41 = httpConnection39.followRedirects(false);
org.jsoup.Connection connection43 = httpConnection39.referrer("");
org.jsoup.Connection.Response response44 = httpConnection39.response();
org.jsoup.Connection connection45 = httpConnection32.response(response44);
org.jsoup.Connection connection47 = httpConnection32.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request48 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method49 = request48.method();
boolean boolean50 = request48.ignoreHttpErrors();
org.jsoup.Connection.Request request53 = request48.cookie("hi!", "");
java.lang.String str55 = request48.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request56 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method57 = request56.method();
boolean boolean58 = request56.followRedirects;
org.jsoup.Connection.Request request60 = request56.followRedirects(true);
java.lang.String str62 = request56.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request63 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method64 = request63.method();
org.jsoup.Connection.Request request65 = request56.method(method64);
org.jsoup.Connection.Request request66 = request48.method(method64);
org.jsoup.Connection connection67 = httpConnection32.method(method64);
org.jsoup.Connection connection69 = httpConnection32.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection httpConnection70 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response71 = httpConnection70.response();
org.jsoup.Connection connection73 = httpConnection70.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection74 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response75 = httpConnection74.response();
httpConnection70.res = response75;
java.lang.String[] strArray79 = new java.lang.String[] { "null=null", "null=null" };
org.jsoup.Connection connection80 = httpConnection70.data(strArray79);
org.jsoup.Connection connection81 = httpConnection32.data(strArray79);
org.jsoup.Connection connection82 = httpConnection24.data(strArray79);
org.jsoup.Connection connection83 = httpConnection12.data(strArray79);
org.jsoup.Connection connection84 = httpConnection6.data(strArray79);
org.jsoup.Connection connection85 = httpConnection0.data(strArray79);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap20);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response36);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request37);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection47);
org.junit.Assert.assertTrue("'" + method49 + "' != '" + org.jsoup.Connection.Method.GET + "'", method49.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean50 + "' != '" + false + "'", boolean50 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str55);
org.junit.Assert.assertTrue("'" + method57 + "' != '" + org.jsoup.Connection.Method.GET + "'", method57.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean58 + "' != '" + true + "'", boolean58 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str62);
org.junit.Assert.assertTrue("'" + method64 + "' != '" + org.jsoup.Connection.Method.GET + "'", method64.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request65);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request66);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection67);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection69);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response71);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection73);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strArray79);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection80);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection81);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection82);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection83);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection84);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection85);
}
@Test
public void test0942() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0942");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.Connection connection8 = httpConnection0.userAgent("null=null");
org.jsoup.helper.HttpConnection.Response response9 = null;
org.jsoup.helper.HttpConnection.Response response10 = new org.jsoup.helper.HttpConnection.Response(response9);
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
boolean boolean15 = request13.followRedirects;
org.jsoup.Connection.Request request17 = request13.followRedirects(true);
java.lang.String str19 = request13.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
org.jsoup.Connection.Request request22 = request13.method(method21);
org.jsoup.Connection.Request request23 = request11.method(method21);
org.jsoup.helper.HttpConnection.KeyVal keyVal24 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str25 = keyVal24.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal27 = keyVal24.value("");
java.lang.String str28 = keyVal24.value();
org.jsoup.helper.HttpConnection.Request request29 = request11.data((org.jsoup.Connection.KeyVal) keyVal24);
int int30 = request29.timeout();
response10.req = request29;
httpConnection0.res = response10;
java.nio.ByteBuffer byteBuffer33 = response10.byteData;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str25 + "' != '" + "null=null" + "'", str25.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str28 + "' != '" + "" + "'", str28.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 3000 + "'", int30 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(byteBuffer33);
}
@Test
public void test0943() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0943");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
java.net.URL uRL5 = request0.url();
boolean boolean6 = request0.ignoreContentType();
java.lang.String str8 = request0.cookie("null=null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
}
@Test
public void test0944() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0944");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.util.Map<java.lang.String, java.lang.String> strMap8 = request7.cookies();
boolean boolean10 = request7.hasHeader("null=null");
java.lang.String str11 = org.jsoup.helper.HttpConnection.Response.getRequestCookieString((org.jsoup.Connection.Request) request7);
request7.followRedirects = false;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + false + "'", boolean10 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str11 + "' != '" + "" + "'", str11.equals(""));
}
@Test
public void test0945() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0945");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap1 = request0.headers();
org.jsoup.Connection.Request request3 = request0.removeHeader("null=null=null=hi!");
java.net.URL uRL4 = request0.url();
int int5 = request0.maxBodySizeBytes;
org.jsoup.Connection.Request request7 = request0.ignoreHttpErrors(false);
org.jsoup.Connection.Request request9 = request0.removeCookie("hi!");
org.jsoup.helper.HttpConnection.Response response10 = null;
org.jsoup.helper.HttpConnection.Response response11 = new org.jsoup.helper.HttpConnection.Response(response10);
int int12 = response11.statusCode();
int int13 = response11.numRedirects;
java.lang.String str14 = response11.charset;
java.lang.String str15 = response11.charset;
org.jsoup.Connection.Response response18 = response11.header("null=", "hi!");
java.lang.String str20 = response11.cookie("");
java.util.Map<java.lang.String, java.lang.String> strMap21 = response11.cookies();
org.jsoup.helper.HttpConnection.Request request22 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method23 = request22.method();
java.util.Map<java.lang.String, java.lang.String> strMap24 = request22.headers();
request22.followRedirects = false;
boolean boolean27 = request22.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request29 = request22.timeout((int) ' ');
boolean boolean30 = request29.ignoreHttpErrors;
org.jsoup.Connection.Method method31 = request29.method();
org.jsoup.Connection.Response response32 = response11.method(method31);
java.lang.String str34 = response11.getHeaderCaseInsensitive("null=null=");
org.jsoup.helper.HttpConnection.Request request35 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method36 = request35.method();
boolean boolean37 = request35.ignoreHttpErrors();
org.jsoup.Connection.Request request40 = request35.cookie("hi!", "");
java.lang.String str42 = request35.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request43 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method44 = request43.method();
boolean boolean45 = request43.followRedirects;
org.jsoup.Connection.Request request47 = request43.followRedirects(true);
java.lang.String str49 = request43.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
org.jsoup.Connection.Request request52 = request43.method(method51);
org.jsoup.Connection.Request request53 = request35.method(method51);
org.jsoup.Connection.Response response54 = response11.method(method51);
org.jsoup.Connection.Request request55 = request0.method(method51);
boolean boolean57 = request0.hasCookie("null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int5 + "' != '" + 1048576 + "'", int5 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 0 + "'", int12 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int13 + "' != '" + 0 + "'", int13 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap21);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean27 + "' != '" + false + "'", boolean27 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean30 + "' != '" + false + "'", boolean30 == false);
org.junit.Assert.assertTrue("'" + method31 + "' != '" + org.jsoup.Connection.Method.GET + "'", method31.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str34);
org.junit.Assert.assertTrue("'" + method36 + "' != '" + org.jsoup.Connection.Method.GET + "'", method36.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str42);
org.junit.Assert.assertTrue("'" + method44 + "' != '" + org.jsoup.Connection.Method.GET + "'", method44.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean45 + "' != '" + true + "'", boolean45 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request47);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str49);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean57 + "' != '" + false + "'", boolean57 == false);
}
@Test
public void test0946() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0946");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
response1.statusCode = (short) -1;
java.util.Map<java.lang.String, java.lang.String> strMap9 = response1.headers();
org.jsoup.helper.HttpConnection.Request request10 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method11 = request10.method();
boolean boolean12 = request10.followRedirects;
org.jsoup.Connection.Request request14 = request10.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap15 = request10.headers();
boolean boolean16 = request10.ignoreContentType;
boolean boolean17 = request10.followRedirects();
org.jsoup.helper.HttpConnection.Request request18 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method19 = request18.method();
org.jsoup.Connection.Request request20 = request10.method(method19);
org.jsoup.Connection.Response response21 = response1.method(method19);
java.lang.String str22 = response1.charset();
// The following exception was thrown during execution in test generation
try {
java.lang.String str23 = response1.body();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before getting response body");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
org.junit.Assert.assertTrue("'" + method11 + "' != '" + org.jsoup.Connection.Method.GET + "'", method11.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + true + "'", boolean12 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean16 + "' != '" + false + "'", boolean16 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
org.junit.Assert.assertTrue("'" + method19 + "' != '" + org.jsoup.Connection.Method.GET + "'", method19.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str22);
}
@Test
public void test0947() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0947");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.toString();
keyVal0.value = "";
keyVal0.value = "null=hi!";
keyVal0.key = "null=null";
java.lang.String str8 = keyVal0.toString();
java.lang.String str9 = keyVal0.value();
org.jsoup.helper.HttpConnection.KeyVal keyVal11 = keyVal0.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = keyVal0.value("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal15 = keyVal13.value("hi!=null");
java.lang.String str16 = keyVal13.toString();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "null=null" + "'", str1.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str8 + "' != '" + "null=null=null=hi!" + "'", str8.equals("null=null=null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str9 + "' != '" + "null=hi!" + "'", str9.equals("null=hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str16 + "' != '" + "null=null=hi!=null" + "'", str16.equals("null=null=hi!=null"));
}
@Test
public void test0948() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0948");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
boolean boolean6 = request0.ignoreContentType;
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "hi!");
java.lang.String str11 = request0.getHeaderCaseInsensitive("");
java.lang.String str13 = request0.cookie("");
request0.ignoreContentType = false;
java.util.Map<java.lang.String, java.lang.String> strMap16 = request0.cookies();
boolean boolean17 = request0.followRedirects();
org.jsoup.helper.HttpConnection.KeyVal keyVal18 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal18.key = "hi!";
java.lang.String str21 = keyVal18.key;
org.jsoup.helper.HttpConnection.Request request22 = request0.data((org.jsoup.Connection.KeyVal) keyVal18);
java.lang.String str23 = keyVal18.toString();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str21 + "' != '" + "hi!" + "'", str21.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str23 + "' != '" + "hi!=null" + "'", str23.equals("hi!=null"));
}
@Test
public void test0949() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0949");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
java.lang.String str9 = request7.cookie("hi!");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection10 = request7.data();
java.lang.String str12 = request7.header("hi!");
boolean boolean14 = request7.hasHeader("null=");
request7.ignoreContentType = true;
java.lang.String str18 = request7.cookie("null=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str18);
}
@Test
public void test0950() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0950");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
java.util.Map<java.lang.String, java.lang.String> strMap3 = request0.headers();
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str5 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = keyVal4.value("hi!");
java.lang.String str8 = keyVal4.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal4.value("hi!");
java.lang.String str11 = keyVal4.key();
org.jsoup.helper.HttpConnection.Request request12 = request0.data((org.jsoup.Connection.KeyVal) keyVal4);
org.jsoup.Connection.Request request14 = request0.maxBodySize((int) (byte) 0);
boolean boolean15 = request0.followRedirects;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
}
@Test
public void test0951() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0951");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.maxBodySize((int) (short) 1);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request6 = null;
org.jsoup.Connection connection7 = httpConnection5.request(request6);
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
org.jsoup.Connection.Request request10 = httpConnection8.request();
org.jsoup.Connection connection11 = httpConnection5.request(request10);
org.jsoup.Connection connection14 = httpConnection5.cookie("null=null", "null=null");
org.jsoup.Connection connection16 = httpConnection5.followRedirects(true);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.cookies();
org.jsoup.Connection connection23 = httpConnection5.data(strMap22);
org.jsoup.Connection connection24 = httpConnection0.data(strMap22);
org.jsoup.helper.HttpConnection.Request request25 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method26 = request25.method();
java.util.Map<java.lang.String, java.lang.String> strMap27 = request25.headers();
request25.followRedirects = false;
java.lang.String str31 = request25.cookie("");
boolean boolean32 = request25.ignoreContentType();
org.jsoup.helper.HttpConnection.Request request33 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method34 = request33.method();
java.util.Map<java.lang.String, java.lang.String> strMap35 = request33.headers();
request33.followRedirects = false;
boolean boolean38 = request33.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection39 = request33.data();
request25.data = keyValCollection39;
org.jsoup.helper.HttpConnection.KeyVal keyVal43 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = keyVal43.key("null=null");
org.jsoup.helper.HttpConnection.Request request46 = request25.data((org.jsoup.Connection.KeyVal) keyVal45);
org.jsoup.helper.HttpConnection.Request request47 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method48 = request47.method();
java.util.Map<java.lang.String, java.lang.String> strMap49 = request47.headers();
request47.followRedirects = false;
boolean boolean52 = request47.ignoreHttpErrors;
org.jsoup.Connection.Method method53 = request47.method();
int int54 = request47.maxBodySizeBytes;
org.jsoup.Connection.Method method55 = request47.method();
org.jsoup.Connection.Request request56 = request25.method(method55);
org.jsoup.Connection connection57 = httpConnection0.request((org.jsoup.Connection.Request) request25);
request25.ignoreContentType = false;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
org.junit.Assert.assertTrue("'" + method26 + "' != '" + org.jsoup.Connection.Method.GET + "'", method26.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str31);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean32 + "' != '" + false + "'", boolean32 == false);
org.junit.Assert.assertTrue("'" + method34 + "' != '" + org.jsoup.Connection.Method.GET + "'", method34.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean38 + "' != '" + false + "'", boolean38 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request46);
org.junit.Assert.assertTrue("'" + method48 + "' != '" + org.jsoup.Connection.Method.GET + "'", method48.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + false + "'", boolean52 == false);
org.junit.Assert.assertTrue("'" + method53 + "' != '" + org.jsoup.Connection.Method.GET + "'", method53.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int54 + "' != '" + 1048576 + "'", int54 == 1048576);
org.junit.Assert.assertTrue("'" + method55 + "' != '" + org.jsoup.Connection.Method.GET + "'", method55.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection57);
}
@Test
public void test0952() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0952");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean3 = request0.hasHeader("null=null");
org.jsoup.Connection.Request request6 = request0.cookie("null=null=null=hi!", "hi!=");
java.net.URL uRL7 = request0.url();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean3 + "' != '" + false + "'", boolean3 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
}
@Test
public void test0953() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0953");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry6 = response1.scanHeaders("");
java.net.URL uRL7 = response1.url();
response1.statusCode = 10;
int int10 = response1.numRedirects;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int10 + "' != '" + 0 + "'", int10 == 0);
}
@Test
public void test0954() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0954");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.charset = "";
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.Connection.Request request9 = request6.ignoreContentType(false);
org.jsoup.Connection.Request request11 = request6.removeCookie("");
int int12 = request6.maxBodySize();
org.jsoup.Connection.Request request14 = request6.followRedirects(false);
response1.req = request6;
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry17 = response1.scanHeaders("null=");
java.nio.ByteBuffer byteBuffer18 = response1.byteData;
boolean boolean19 = response1.executed;
java.nio.ByteBuffer byteBuffer20 = null;
response1.byteData = byteBuffer20;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int12 + "' != '" + 1048576 + "'", int12 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(byteBuffer18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + false + "'", boolean19 == false);
}
@Test
public void test0955() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0955");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
request0.followRedirects = false;
java.lang.String str10 = request0.header("null=null=null=hi!");
int int11 = request0.timeoutMilliseconds;
org.jsoup.Connection.Request request14 = request0.header("null=null", "");
java.util.Map<java.lang.String, java.lang.String> strMap15 = request0.headers();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3000 + "'", int11 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap15);
}
@Test
public void test0956() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0956");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.parser.Parser parser7 = null;
org.jsoup.Connection connection8 = httpConnection0.parser(parser7);
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
java.util.Map<java.lang.String, java.lang.String> strMap11 = request9.headers();
request9.followRedirects = false;
boolean boolean14 = request9.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection15 = request9.data();
org.jsoup.Connection connection16 = httpConnection0.data(keyValCollection15);
org.jsoup.Connection connection18 = httpConnection0.maxBodySize((int) ' ');
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection18);
}
@Test
public void test0957() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0957");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
org.jsoup.Connection connection7 = httpConnection4.maxBodySize((int) (short) 0);
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
httpConnection4.res = response9;
httpConnection0.res = response9;
org.jsoup.Connection connection14 = httpConnection0.header("hi!", "");
java.net.URL uRL15 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection16 = httpConnection0.url(uRL15);
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: URL must not be null");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
}
@Test
public void test0958() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0958");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection.Response response5 = httpConnection0.res;
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method7 = request6.method();
org.jsoup.helper.HttpConnection.Request request8 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method9 = request8.method();
boolean boolean10 = request8.followRedirects;
org.jsoup.Connection.Request request12 = request8.followRedirects(true);
java.lang.String str14 = request8.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
org.jsoup.Connection.Request request17 = request8.method(method16);
org.jsoup.Connection.Request request18 = request6.method(method16);
boolean boolean20 = request6.hasHeader("hi!");
org.jsoup.Connection.Request request22 = request6.removeCookie("");
httpConnection0.req = request22;
org.jsoup.helper.HttpConnection httpConnection24 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request25 = null;
org.jsoup.Connection connection26 = httpConnection24.request(request25);
org.jsoup.helper.HttpConnection httpConnection27 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response28 = httpConnection27.response();
org.jsoup.Connection connection29 = httpConnection24.response(response28);
httpConnection0.res = response28;
org.jsoup.Connection connection32 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection35 = httpConnection0.data("null=null=null=hi!=hi!", "hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
org.junit.Assert.assertTrue("'" + method7 + "' != '" + org.jsoup.Connection.Method.GET + "'", method7.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method9 + "' != '" + org.jsoup.Connection.Method.GET + "'", method9.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean10 + "' != '" + true + "'", boolean10 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str14);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean20 + "' != '" + false + "'", boolean20 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection35);
}
@Test
public void test0959() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0959");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request1 = null;
org.jsoup.Connection connection2 = httpConnection0.request(request1);
org.jsoup.helper.HttpConnection httpConnection3 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response4 = httpConnection3.response();
org.jsoup.Connection connection5 = httpConnection0.response(response4);
org.jsoup.helper.HttpConnection.Response response6 = null;
org.jsoup.helper.HttpConnection.Response response7 = new org.jsoup.helper.HttpConnection.Response(response6);
int int8 = response7.statusCode();
int int9 = response7.numRedirects;
java.lang.String str10 = response7.charset;
java.lang.String str11 = response7.statusMessage;
java.util.Map<java.lang.String, java.lang.String> strMap12 = response7.headers();
org.jsoup.Connection connection13 = httpConnection0.cookies(strMap12);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection15 = httpConnection0.timeout((int) (short) 10);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int8 + "' != '" + 0 + "'", int8 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 0 + "'", int9 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
}
@Test
public void test0960() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0960");
java.lang.String str1 = org.jsoup.helper.HttpConnection.encodeUrl("null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str1 + "' != '" + "null=null=hi!" + "'", str1.equals("null=null=hi!"));
}
@Test
public void test0961() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0961");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.referrer("");
org.jsoup.Connection connection6 = httpConnection0.ignoreContentType(false);
// The following exception was thrown during execution in test generation
try {
org.jsoup.Connection connection9 = httpConnection0.header("", "hi!=");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
}
@Test
public void test0962() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0962");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!=null", "hi!=null");
java.lang.String str3 = keyVal2.key;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str3 + "' != '" + "hi!=null" + "'", str3.equals("hi!=null"));
}
@Test
public void test0963() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0963");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
org.jsoup.Connection.Request request7 = response1.req;
response1.statusMessage = "hi!=null";
org.jsoup.helper.HttpConnection.Response response10 = new org.jsoup.helper.HttpConnection.Response(response1);
org.jsoup.helper.HttpConnection.Response response11 = new org.jsoup.helper.HttpConnection.Response(response10);
response11.statusMessage = "hi!";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(request7);
}
@Test
public void test0964() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0964");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.maxBodySize((int) (short) 1);
org.jsoup.Connection connection6 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
org.jsoup.parser.Parser parser14 = null;
org.jsoup.Connection connection15 = httpConnection7.parser(parser14);
org.jsoup.helper.HttpConnection.Request request16 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method17 = request16.method();
java.util.Map<java.lang.String, java.lang.String> strMap18 = request16.headers();
request16.followRedirects = false;
boolean boolean21 = request16.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection22 = request16.data();
org.jsoup.Connection connection23 = httpConnection7.data(keyValCollection22);
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
boolean boolean26 = request24.followRedirects;
org.jsoup.Connection.Request request28 = request24.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap29 = request24.headers();
request24.timeoutMilliseconds = 307;
org.jsoup.helper.HttpConnection.Request request32 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method33 = request32.method();
java.util.Map<java.lang.String, java.lang.String> strMap34 = request32.headers();
request32.followRedirects = false;
boolean boolean37 = request32.ignoreHttpErrors;
org.jsoup.Connection.Method method38 = request32.method();
int int39 = request32.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request40 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method41 = request40.method();
boolean boolean42 = request40.followRedirects;
org.jsoup.Connection.Request request44 = request40.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap45 = request40.headers();
boolean boolean46 = request40.ignoreContentType;
boolean boolean47 = request40.followRedirects();
org.jsoup.helper.HttpConnection.Request request48 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method49 = request48.method();
org.jsoup.Connection.Request request50 = request40.method(method49);
org.jsoup.Connection.Request request51 = request32.method(method49);
org.jsoup.Connection.Request request52 = request24.method(method49);
org.jsoup.Connection connection53 = httpConnection7.method(method49);
org.jsoup.Connection connection54 = httpConnection0.method(method49);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
org.junit.Assert.assertTrue("'" + method17 + "' != '" + org.jsoup.Connection.Method.GET + "'", method17.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + true + "'", boolean26 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap29);
org.junit.Assert.assertTrue("'" + method33 + "' != '" + org.jsoup.Connection.Method.GET + "'", method33.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean37 + "' != '" + false + "'", boolean37 == false);
org.junit.Assert.assertTrue("'" + method38 + "' != '" + org.jsoup.Connection.Method.GET + "'", method38.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int39 + "' != '" + 1048576 + "'", int39 == 1048576);
org.junit.Assert.assertTrue("'" + method41 + "' != '" + org.jsoup.Connection.Method.GET + "'", method41.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean42 + "' != '" + true + "'", boolean42 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap45);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean46 + "' != '" + false + "'", boolean46 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + true + "'", boolean47 == true);
org.junit.Assert.assertTrue("'" + method49 + "' != '" + org.jsoup.Connection.Method.GET + "'", method49.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request51);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request52);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection53);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection54);
}
@Test
public void test0965() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0965");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
response1.charset = "hi!=null";
org.jsoup.Connection.Response response6 = response1.removeHeader("hi!=");
java.lang.String str7 = response1.contentType();
boolean boolean9 = response1.hasCookie("hi!=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean9 + "' != '" + false + "'", boolean9 == false);
}
@Test
public void test0966() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0966");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection connection4 = httpConnection0.ignoreContentType(true);
org.jsoup.Connection.Request request5 = httpConnection0.request();
org.jsoup.helper.HttpConnection.Request request6 = new org.jsoup.helper.HttpConnection.Request();
request6.maxBodySizeBytes = (-1);
org.jsoup.Connection.Request request11 = request6.header("null=null=null=hi!", "null=hi!");
httpConnection0.req = request6;
org.jsoup.Connection connection14 = httpConnection0.userAgent("");
org.jsoup.helper.HttpConnection.Response response15 = null;
org.jsoup.helper.HttpConnection.Response response16 = new org.jsoup.helper.HttpConnection.Response(response15);
java.lang.String str17 = response16.contentType();
java.net.URL uRL18 = response16.url();
httpConnection0.res = response16;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL18);
}
@Test
public void test0967() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0967");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.Connection connection7 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection10 = httpConnection0.cookie("null=null", "null=null=null=hi!");
org.jsoup.Connection connection12 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Response response13 = httpConnection0.res;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response13);
}
@Test
public void test0968() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0968");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.lang.String str5 = response1.contentType();
java.lang.String str7 = response1.cookie("null=null");
org.jsoup.helper.HttpConnection.Response response8 = new org.jsoup.helper.HttpConnection.Response(response1);
org.jsoup.Connection.Response response10 = response1.removeHeader("null=hi!");
java.lang.String str12 = response1.getHeaderCaseInsensitive("null=");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry14 = response1.scanHeaders("null=null=null=hi!");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry14);
}
@Test
public void test0969() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0969");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request0.followRedirects();
org.jsoup.Connection.Request request10 = request0.removeHeader("null=null=null=hi!");
org.jsoup.Connection.Request request12 = request0.ignoreContentType(false);
org.jsoup.Connection.Request request14 = request0.ignoreContentType(true);
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
}
@Test
public void test0970() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0970");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
org.jsoup.Connection.Request request8 = request0.cookie("null=null=", "null=null=null=hi!=hi!");
int int9 = request0.timeout();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 3000 + "'", int9 == 3000);
}
@Test
public void test0971() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0971");
org.jsoup.helper.HttpConnection.KeyVal keyVal2 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "");
org.jsoup.helper.HttpConnection.KeyVal keyVal4 = keyVal2.value("hi!=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal6 = keyVal4.key("null=null");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal6);
}
@Test
public void test0972() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0972");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
boolean boolean4 = request0.hasCookie("null=hi!");
request0.timeoutMilliseconds = (byte) -1;
org.jsoup.helper.HttpConnection.KeyVal keyVal7 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str8 = keyVal7.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal10 = keyVal7.value("hi!");
java.lang.String str11 = keyVal7.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = keyVal7.value("hi!");
org.jsoup.helper.HttpConnection.Request request14 = request0.data((org.jsoup.Connection.KeyVal) keyVal13);
request0.maxBodySizeBytes = 0;
org.jsoup.helper.HttpConnection httpConnection17 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response18 = httpConnection17.response();
org.jsoup.Connection connection20 = httpConnection17.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection21 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response22 = httpConnection21.response();
httpConnection17.res = response22;
org.jsoup.parser.Parser parser24 = null;
org.jsoup.Connection connection25 = httpConnection17.parser(parser24);
org.jsoup.helper.HttpConnection.Request request26 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method27 = request26.method();
java.util.Map<java.lang.String, java.lang.String> strMap28 = request26.headers();
request26.followRedirects = false;
boolean boolean31 = request26.ignoreHttpErrors;
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection32 = request26.data();
org.jsoup.Connection connection33 = httpConnection17.data(keyValCollection32);
org.jsoup.helper.HttpConnection.Request request34 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method35 = request34.method();
boolean boolean36 = request34.followRedirects;
org.jsoup.Connection.Request request38 = request34.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap39 = request34.headers();
request34.timeoutMilliseconds = 307;
org.jsoup.helper.HttpConnection.Request request42 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method43 = request42.method();
java.util.Map<java.lang.String, java.lang.String> strMap44 = request42.headers();
request42.followRedirects = false;
boolean boolean47 = request42.ignoreHttpErrors;
org.jsoup.Connection.Method method48 = request42.method();
int int49 = request42.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request50 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method51 = request50.method();
boolean boolean52 = request50.followRedirects;
org.jsoup.Connection.Request request54 = request50.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap55 = request50.headers();
boolean boolean56 = request50.ignoreContentType;
boolean boolean57 = request50.followRedirects();
org.jsoup.helper.HttpConnection.Request request58 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method59 = request58.method();
org.jsoup.Connection.Request request60 = request50.method(method59);
org.jsoup.Connection.Request request61 = request42.method(method59);
org.jsoup.Connection.Request request62 = request34.method(method59);
org.jsoup.Connection connection63 = httpConnection17.method(method59);
org.jsoup.Connection.Request request64 = request0.method(method59);
org.jsoup.Connection.Request request66 = request0.ignoreHttpErrors(false);
int int67 = request0.timeoutMilliseconds;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + false + "'", boolean4 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection25);
org.junit.Assert.assertTrue("'" + method27 + "' != '" + org.jsoup.Connection.Method.GET + "'", method27.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean31 + "' != '" + false + "'", boolean31 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection32);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection33);
org.junit.Assert.assertTrue("'" + method35 + "' != '" + org.jsoup.Connection.Method.GET + "'", method35.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + true + "'", boolean36 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap39);
org.junit.Assert.assertTrue("'" + method43 + "' != '" + org.jsoup.Connection.Method.GET + "'", method43.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap44);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean47 + "' != '" + false + "'", boolean47 == false);
org.junit.Assert.assertTrue("'" + method48 + "' != '" + org.jsoup.Connection.Method.GET + "'", method48.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int49 + "' != '" + 1048576 + "'", int49 == 1048576);
org.junit.Assert.assertTrue("'" + method51 + "' != '" + org.jsoup.Connection.Method.GET + "'", method51.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean52 + "' != '" + true + "'", boolean52 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request54);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap55);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean56 + "' != '" + false + "'", boolean56 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean57 + "' != '" + true + "'", boolean57 == true);
org.junit.Assert.assertTrue("'" + method59 + "' != '" + org.jsoup.Connection.Method.GET + "'", method59.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request60);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request61);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request62);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection63);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request64);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request66);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int67 + "' != '" + (-1) + "'", int67 == (-1));
}
@Test
public void test0973() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0973");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.followRedirects = false;
boolean boolean5 = request0.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request7 = request0.timeout((int) ' ');
boolean boolean8 = request7.followRedirects();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry10 = request7.scanHeaders("");
java.lang.String str12 = request7.cookie("null=null=hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal13 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal13.key = "hi!";
java.lang.String str16 = keyVal13.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal18 = keyVal13.key("hi!");
java.lang.String str19 = keyVal13.value();
keyVal13.key = "null=";
org.jsoup.helper.HttpConnection.KeyVal keyVal23 = keyVal13.value("null=null=hi!");
org.jsoup.helper.HttpConnection.Request request24 = request7.data((org.jsoup.Connection.KeyVal) keyVal13);
org.jsoup.helper.HttpConnection httpConnection25 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response26 = httpConnection25.response();
org.jsoup.Connection connection28 = httpConnection25.followRedirects(false);
org.jsoup.Connection connection30 = httpConnection25.ignoreHttpErrors(true);
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
java.util.Map<java.lang.String, java.lang.String> strMap33 = request31.headers();
request31.followRedirects = false;
boolean boolean36 = request31.ignoreHttpErrors;
org.jsoup.helper.HttpConnection.Request request38 = request31.timeout((int) ' ');
boolean boolean39 = request38.ignoreContentType;
org.jsoup.helper.HttpConnection.KeyVal keyVal42 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
keyVal42.key = "";
org.jsoup.helper.HttpConnection.KeyVal keyVal45 = new org.jsoup.helper.HttpConnection.KeyVal();
org.jsoup.helper.HttpConnection.KeyVal keyVal48 = new org.jsoup.helper.HttpConnection.KeyVal("hi!", "hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal50 = keyVal48.key("null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal51 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal51.key = "hi!";
java.lang.String str54 = keyVal51.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal56 = keyVal51.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal59 = org.jsoup.helper.HttpConnection.KeyVal.create("hi!", "null=null");
org.jsoup.helper.HttpConnection.KeyVal keyVal60 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal60.key = "hi!";
java.lang.String str63 = keyVal60.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal64 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str65 = keyVal64.toString();
keyVal64.value = "";
keyVal64.value = "null=hi!";
org.jsoup.helper.HttpConnection.KeyVal keyVal70 = new org.jsoup.helper.HttpConnection.KeyVal();
keyVal70.key = "hi!";
java.lang.String str73 = keyVal70.key;
org.jsoup.helper.HttpConnection.KeyVal keyVal75 = keyVal70.key("hi!");
org.jsoup.helper.HttpConnection.KeyVal keyVal76 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str77 = keyVal76.key();
org.jsoup.Connection.KeyVal[] keyValArray78 = new org.jsoup.Connection.KeyVal[] { keyVal42, keyVal45, keyVal50, keyVal51, keyVal59, keyVal60, keyVal64, keyVal70, keyVal76 };
java.util.ArrayList<org.jsoup.Connection.KeyVal> keyValList79 = new java.util.ArrayList<org.jsoup.Connection.KeyVal>();
boolean boolean80 = java.util.Collections.addAll((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList79, keyValArray78);
request38.data = keyValList79;
org.jsoup.Connection connection82 = httpConnection25.data((java.util.Collection<org.jsoup.Connection.KeyVal>) keyValList79);
request7.data = keyValList79;
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean8 + "' != '" + false + "'", boolean8 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str16 + "' != '" + "hi!" + "'", str16.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection30);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean36 + "' != '" + false + "'", boolean36 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean39 + "' != '" + false + "'", boolean39 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal50);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str54 + "' != '" + "hi!" + "'", str54.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal56);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal59);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str63 + "' != '" + "hi!" + "'", str63.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str65 + "' != '" + "null=null" + "'", str65.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str73 + "' != '" + "hi!" + "'", str73.equals("hi!"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal75);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str77);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValArray78);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean80 + "' != '" + true + "'", boolean80 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection82);
}
@Test
public void test0974() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0974");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.followRedirects(false);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response6 = httpConnection5.response();
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response8 = httpConnection7.response();
org.jsoup.Connection connection10 = httpConnection7.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection11 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response12 = httpConnection11.response();
httpConnection7.res = response12;
httpConnection5.res = response12;
org.jsoup.Connection connection15 = httpConnection0.response(response12);
org.jsoup.Connection connection17 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection19 = httpConnection0.referrer("hi!");
org.jsoup.Connection connection21 = httpConnection0.referrer("null=null=null=hi!");
org.jsoup.helper.HttpConnection.Request request22 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method23 = request22.method();
org.jsoup.helper.HttpConnection.Request request24 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method25 = request24.method();
boolean boolean26 = request24.followRedirects;
org.jsoup.Connection.Request request28 = request24.followRedirects(true);
java.lang.String str30 = request24.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
org.jsoup.Connection.Request request33 = request24.method(method32);
org.jsoup.Connection.Request request34 = request22.method(method32);
org.jsoup.helper.HttpConnection.KeyVal keyVal35 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str36 = keyVal35.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal38 = keyVal35.value("");
java.lang.String str39 = keyVal35.value();
org.jsoup.helper.HttpConnection.Request request40 = request22.data((org.jsoup.Connection.KeyVal) keyVal35);
int int41 = request40.timeout();
request40.maxBodySizeBytes = 3000;
httpConnection0.req = request40;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection21);
org.junit.Assert.assertTrue("'" + method23 + "' != '" + org.jsoup.Connection.Method.GET + "'", method23.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method25 + "' != '" + org.jsoup.Connection.Method.GET + "'", method25.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean26 + "' != '" + true + "'", boolean26 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str30);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request33);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request34);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str36 + "' != '" + "null=null" + "'", str36.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal38);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str39 + "' != '" + "" + "'", str39.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int41 + "' != '" + 3000 + "'", int41 == 3000);
}
@Test
public void test0975() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0975");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
request0.timeoutMilliseconds = 307;
org.jsoup.parser.Parser parser8 = request0.parser();
java.util.Map<java.lang.String, java.lang.String> strMap9 = request0.cookies();
java.util.Map<java.lang.String, java.lang.String> strMap10 = request0.cookies();
boolean boolean11 = request0.followRedirects();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + true + "'", boolean11 == true);
}
@Test
public void test0976() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0976");
org.jsoup.helper.HttpConnection.KeyVal keyVal0 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str1 = keyVal0.key();
org.jsoup.helper.HttpConnection.KeyVal keyVal3 = keyVal0.value("hi!");
keyVal0.value = "null=null=null=hi!";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal3);
}
@Test
public void test0977() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0977");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.referrer("");
org.jsoup.Connection.Response response5 = httpConnection0.response();
org.jsoup.Connection connection7 = httpConnection0.followRedirects(false);
org.jsoup.Connection.Request request8 = httpConnection0.request();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request8);
}
@Test
public void test0978() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0978");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection.Request request4 = httpConnection0.request();
org.jsoup.Connection connection6 = httpConnection0.maxBodySize((int) (short) 0);
org.jsoup.helper.HttpConnection httpConnection7 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request8 = null;
org.jsoup.Connection connection9 = httpConnection7.request(request8);
org.jsoup.helper.HttpConnection httpConnection10 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response11 = httpConnection10.response();
org.jsoup.Connection.Request request12 = httpConnection10.request();
org.jsoup.Connection connection13 = httpConnection7.request(request12);
org.jsoup.helper.HttpConnection httpConnection14 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection16 = httpConnection14.followRedirects(false);
org.jsoup.Connection connection18 = httpConnection14.referrer("");
org.jsoup.Connection.Response response19 = httpConnection14.response();
org.jsoup.Connection connection20 = httpConnection7.response(response19);
org.jsoup.Connection connection22 = httpConnection7.followRedirects(false);
org.jsoup.helper.HttpConnection.Request request23 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method24 = request23.method();
boolean boolean25 = request23.ignoreHttpErrors();
org.jsoup.Connection.Request request28 = request23.cookie("hi!", "");
java.lang.String str30 = request23.cookie("null=hi!");
org.jsoup.helper.HttpConnection.Request request31 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method32 = request31.method();
boolean boolean33 = request31.followRedirects;
org.jsoup.Connection.Request request35 = request31.followRedirects(true);
java.lang.String str37 = request31.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request38 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method39 = request38.method();
org.jsoup.Connection.Request request40 = request31.method(method39);
org.jsoup.Connection.Request request41 = request23.method(method39);
org.jsoup.Connection connection42 = httpConnection7.method(method39);
org.jsoup.Connection connection43 = httpConnection0.method(method39);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection18);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection22);
org.junit.Assert.assertTrue("'" + method24 + "' != '" + org.jsoup.Connection.Method.GET + "'", method24.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean25 + "' != '" + false + "'", boolean25 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request28);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str30);
org.junit.Assert.assertTrue("'" + method32 + "' != '" + org.jsoup.Connection.Method.GET + "'", method32.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean33 + "' != '" + true + "'", boolean33 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request35);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str37);
org.junit.Assert.assertTrue("'" + method39 + "' != '" + org.jsoup.Connection.Method.GET + "'", method39.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request40);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request41);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection42);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection43);
}
@Test
public void test0979() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0979");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
java.lang.String str8 = request0.cookie("null=null=null=hi!");
org.jsoup.Connection.Request request10 = request0.removeCookie("null=hi!");
boolean boolean11 = request0.followRedirects();
// The following exception was thrown during execution in test generation
try {
boolean boolean13 = request0.hasHeader("");
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Header name must not be empty");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + true + "'", boolean11 == true);
}
@Test
public void test0980() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0980");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
response1.contentType = "null=null=null=hi!";
java.util.Map<java.lang.String, java.lang.String> strMap7 = response1.headers();
java.lang.String str8 = response1.contentType();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str8 + "' != '" + "null=null=null=hi!" + "'", str8.equals("null=null=null=hi!"));
}
@Test
public void test0981() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0981");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection connection3 = httpConnection0.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection4 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response5 = httpConnection4.response();
httpConnection0.res = response5;
org.jsoup.Connection connection8 = httpConnection0.userAgent("null=null");
org.jsoup.helper.HttpConnection.Response response9 = null;
org.jsoup.helper.HttpConnection.Response response10 = new org.jsoup.helper.HttpConnection.Response(response9);
org.jsoup.helper.HttpConnection.Request request11 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method12 = request11.method();
org.jsoup.helper.HttpConnection.Request request13 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method14 = request13.method();
boolean boolean15 = request13.followRedirects;
org.jsoup.Connection.Request request17 = request13.followRedirects(true);
java.lang.String str19 = request13.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request20 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method21 = request20.method();
org.jsoup.Connection.Request request22 = request13.method(method21);
org.jsoup.Connection.Request request23 = request11.method(method21);
org.jsoup.helper.HttpConnection.KeyVal keyVal24 = new org.jsoup.helper.HttpConnection.KeyVal();
java.lang.String str25 = keyVal24.toString();
org.jsoup.helper.HttpConnection.KeyVal keyVal27 = keyVal24.value("");
java.lang.String str28 = keyVal24.value();
org.jsoup.helper.HttpConnection.Request request29 = request11.data((org.jsoup.Connection.KeyVal) keyVal24);
int int30 = request29.timeout();
response10.req = request29;
httpConnection0.res = response10;
org.jsoup.Connection.Method method33 = response10.method();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection8);
org.junit.Assert.assertTrue("'" + method12 + "' != '" + org.jsoup.Connection.Method.GET + "'", method12.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method14 + "' != '" + org.jsoup.Connection.Method.GET + "'", method14.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean15 + "' != '" + true + "'", boolean15 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str19);
org.junit.Assert.assertTrue("'" + method21 + "' != '" + org.jsoup.Connection.Method.GET + "'", method21.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str25 + "' != '" + "null=null" + "'", str25.equals("null=null"));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyVal27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + str28 + "' != '" + "" + "'", str28.equals(""));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request29);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 3000 + "'", int30 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(method33);
}
@Test
public void test0982() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0982");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response1 = httpConnection0.response();
org.jsoup.Connection.Request request2 = httpConnection0.request();
org.jsoup.Connection.Request request3 = httpConnection0.req;
org.jsoup.Connection connection5 = httpConnection0.timeout((int) 'a');
org.jsoup.Connection connection7 = httpConnection0.ignoreHttpErrors(false);
org.jsoup.Connection connection10 = httpConnection0.cookie("null=null", "null=null=null=hi!");
org.jsoup.Connection connection12 = httpConnection0.followRedirects(true);
org.jsoup.Connection.Request request13 = httpConnection0.req;
org.jsoup.helper.HttpConnection httpConnection14 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response15 = httpConnection14.response();
org.jsoup.Connection connection17 = httpConnection14.followRedirects(true);
org.jsoup.helper.HttpConnection httpConnection18 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response19 = httpConnection18.response();
httpConnection14.res = response19;
org.jsoup.helper.HttpConnection.Request request21 = new org.jsoup.helper.HttpConnection.Request();
java.util.Map<java.lang.String, java.lang.String> strMap22 = request21.headers();
org.jsoup.Connection connection23 = httpConnection14.request((org.jsoup.Connection.Request) request21);
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry25 = request21.scanHeaders("null=null");
org.jsoup.Connection connection26 = httpConnection0.request((org.jsoup.Connection.Request) request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response1);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request13);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
}
@Test
public void test0983() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0983");
org.jsoup.helper.HttpConnection.HTTP_TEMP_REDIR = (byte) 100;
}
@Test
public void test0984() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0984");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.Connection.Request request3 = request0.ignoreContentType(false);
org.jsoup.parser.Parser parser4 = null;
request0.parser = parser4;
int int6 = request0.timeoutMilliseconds;
java.util.Map<java.lang.String, java.lang.String> strMap7 = request0.headers();
java.lang.String str9 = request0.cookie("null=null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int6 + "' != '" + 3000 + "'", int6 == 3000);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str9);
}
@Test
public void test0985() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0985");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
java.lang.String str2 = response1.contentType();
java.lang.String str3 = response1.contentType();
response1.numRedirects = 1;
// The following exception was thrown during execution in test generation
try {
org.jsoup.nodes.Document document6 = response1.parse();
org.junit.Assert.fail("Expected exception of type java.lang.IllegalArgumentException; message: Request must be executed (with .execute(), .get(), or .post() before parsing response");
} catch (java.lang.IllegalArgumentException e) {
// Expected exception.
}
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str3);
}
@Test
public void test0986() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0986");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
java.net.URL uRL15 = request0.url();
org.jsoup.Connection.Request request17 = request0.removeCookie("");
int int18 = request0.timeout();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL15);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request17);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int18 + "' != '" + 3000 + "'", int18 == 3000);
}
@Test
public void test0987() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0987");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "null=null");
java.lang.String str11 = request0.getHeaderCaseInsensitive("hi!=");
org.jsoup.Connection.Request request14 = request0.cookie("null=hi!", "hi!=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request14);
}
@Test
public void test0988() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0988");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.headers();
boolean boolean6 = request0.ignoreContentType;
boolean boolean7 = request0.followRedirects();
org.jsoup.Connection.Request request9 = request0.removeHeader("null=null=null=hi!=hi!");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + true + "'", boolean7 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
}
@Test
public void test0989() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0989");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
response1.charset = "hi!=null";
java.lang.String str8 = response1.statusMessage;
java.util.Map<java.lang.String, java.lang.String> strMap9 = response1.headers();
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
}
@Test
public void test0990() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0990");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
boolean boolean6 = request0.hasHeader("hi!=null");
org.jsoup.helper.HttpConnection.Request request7 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method8 = request7.method();
java.util.Map<java.lang.String, java.lang.String> strMap9 = request7.headers();
request7.followRedirects = false;
boolean boolean12 = request7.ignoreHttpErrors;
org.jsoup.Connection.Method method13 = request7.method();
int int14 = request7.maxBodySizeBytes;
org.jsoup.helper.HttpConnection.Request request15 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method16 = request15.method();
boolean boolean17 = request15.followRedirects;
org.jsoup.Connection.Request request19 = request15.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap20 = request15.headers();
boolean boolean21 = request15.ignoreContentType;
boolean boolean22 = request15.followRedirects();
org.jsoup.helper.HttpConnection.Request request23 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method24 = request23.method();
org.jsoup.Connection.Request request25 = request15.method(method24);
org.jsoup.Connection.Request request26 = request7.method(method24);
org.jsoup.Connection.Request request27 = request0.method(method24);
org.jsoup.helper.HttpConnection.Response response28 = null;
org.jsoup.helper.HttpConnection.Response response29 = new org.jsoup.helper.HttpConnection.Response(response28);
int int30 = response29.statusCode();
int int31 = response29.numRedirects;
java.lang.String str32 = response29.charset;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response response33 = org.jsoup.helper.HttpConnection.Response.execute(request27, response29);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
org.junit.Assert.assertTrue("'" + method8 + "' != '" + org.jsoup.Connection.Method.GET + "'", method8.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean12 + "' != '" + false + "'", boolean12 == false);
org.junit.Assert.assertTrue("'" + method13 + "' != '" + org.jsoup.Connection.Method.GET + "'", method13.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int14 + "' != '" + 1048576 + "'", int14 == 1048576);
org.junit.Assert.assertTrue("'" + method16 + "' != '" + org.jsoup.Connection.Method.GET + "'", method16.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean17 + "' != '" + true + "'", boolean17 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request19);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap20);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean21 + "' != '" + false + "'", boolean21 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean22 + "' != '" + true + "'", boolean22 == true);
org.junit.Assert.assertTrue("'" + method24 + "' != '" + org.jsoup.Connection.Method.GET + "'", method24.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request25);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request26);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request27);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int30 + "' != '" + 0 + "'", int30 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int31 + "' != '" + 0 + "'", int31 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str32);
}
@Test
public void test0991() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0991");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.ignoreHttpErrors();
org.jsoup.Connection.Request request5 = request0.cookie("hi!", "");
java.lang.String str7 = request0.cookie("null=hi!");
java.util.Map<java.lang.String, java.lang.String> strMap8 = request0.cookies();
int int9 = request0.maxBodySize();
org.jsoup.Connection.Request request12 = request0.header("hi!", "null=null=null=hi!=hi!");
boolean boolean13 = request0.ignoreHttpErrors();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + false + "'", boolean2 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int9 + "' != '" + 1048576 + "'", int9 == 1048576);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + false + "'", boolean13 == false);
}
@Test
public void test0992() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0992");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.lang.String str6 = request0.header("null=hi!");
org.jsoup.Connection.Request request9 = request0.cookie("null=hi!", "null=null");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry11 = request0.scanHeaders("null=null=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry11);
}
@Test
public void test0993() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0993");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
response1.contentType = "null=hi!";
java.lang.String str6 = response1.statusMessage;
response1.executed = true;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str6);
}
@Test
public void test0994() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0994");
org.jsoup.helper.HttpConnection httpConnection0 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection connection2 = httpConnection0.followRedirects(false);
org.jsoup.Connection connection4 = httpConnection0.maxBodySize((int) (short) 1);
org.jsoup.helper.HttpConnection httpConnection5 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Request request6 = null;
org.jsoup.Connection connection7 = httpConnection5.request(request6);
org.jsoup.helper.HttpConnection httpConnection8 = new org.jsoup.helper.HttpConnection();
org.jsoup.Connection.Response response9 = httpConnection8.response();
org.jsoup.Connection.Request request10 = httpConnection8.request();
org.jsoup.Connection connection11 = httpConnection5.request(request10);
org.jsoup.Connection connection14 = httpConnection5.cookie("null=null", "null=null");
org.jsoup.Connection connection16 = httpConnection5.followRedirects(true);
org.jsoup.helper.HttpConnection.Request request17 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method18 = request17.method();
boolean boolean19 = request17.followRedirects;
org.jsoup.Connection.Request request21 = request17.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap22 = request17.cookies();
org.jsoup.Connection connection23 = httpConnection5.data(strMap22);
org.jsoup.Connection connection24 = httpConnection0.data(strMap22);
org.jsoup.Connection connection26 = httpConnection0.referrer("null=null=");
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection14);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection16);
org.junit.Assert.assertTrue("'" + method18 + "' != '" + org.jsoup.Connection.Method.GET + "'", method18.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean19 + "' != '" + true + "'", boolean19 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request21);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap22);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection23);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection24);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(connection26);
}
@Test
public void test0995() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0995");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean14 = request0.hasHeader("hi!");
org.jsoup.Connection.Request request16 = request0.removeCookie("");
java.util.Collection<org.jsoup.Connection.KeyVal> keyValCollection17 = request0.data();
java.io.OutputStream outputStream18 = null;
// The following exception was thrown during execution in test generation
try {
org.jsoup.helper.HttpConnection.Response.writePost(keyValCollection17, outputStream18);
org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
} catch (java.lang.NullPointerException e) {
// Expected exception.
}
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request16);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(keyValCollection17);
}
@Test
public void test0996() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0996");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
boolean boolean2 = request0.followRedirects;
org.jsoup.Connection.Request request4 = request0.followRedirects(true);
java.util.Map<java.lang.String, java.lang.String> strMap5 = request0.cookies();
boolean boolean7 = request0.hasCookie("null=null");
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry9 = request0.scanHeaders("hi!");
boolean boolean11 = request0.hasHeader("null=null=hi!=null");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean2 + "' != '" + true + "'", boolean2 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean7 + "' != '" + false + "'", boolean7 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry9);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean11 + "' != '" + false + "'", boolean11 == false);
}
@Test
public void test0997() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0997");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
int int3 = response1.numRedirects;
java.lang.String str4 = response1.charset;
java.net.URL uRL5 = response1.url();
org.jsoup.Connection.Response response8 = response1.header("null=null=hi!", "null=null=hi!");
java.nio.ByteBuffer byteBuffer9 = response1.byteData;
response1.charset = "null=null=";
response1.statusMessage = "";
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int3 + "' != '" + 0 + "'", int3 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str4);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(uRL5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(response8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(byteBuffer9);
}
@Test
public void test0998() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0998");
org.jsoup.helper.HttpConnection.Response response0 = null;
org.jsoup.helper.HttpConnection.Response response1 = new org.jsoup.helper.HttpConnection.Response(response0);
int int2 = response1.statusCode();
java.lang.String str3 = response1.contentType();
boolean boolean5 = response1.hasCookie("null=null=hi!");
boolean boolean6 = response1.executed;
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int2 + "' != '" + 0 + "'", int2 == 0);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str3);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean5 + "' != '" + false + "'", boolean5 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean6 + "' != '" + false + "'", boolean6 == false);
}
@Test
public void test0999() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test0999");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
java.util.Map<java.lang.String, java.lang.String> strMap2 = request0.headers();
request0.ignoreHttpErrors = false;
org.jsoup.parser.Parser parser5 = request0.parser;
org.jsoup.Connection.Request request7 = request0.removeCookie("");
java.util.Map<java.lang.String, java.lang.String> strMap8 = request0.headers();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry10 = request0.scanHeaders("null=hi!");
int int11 = request0.timeout();
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap2);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(parser5);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request7);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(strMap8);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry10);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + int11 + "' != '" + 3000 + "'", int11 == 3000);
}
@Test
public void test1000() throws Throwable {
if (debug)
System.out.format("%n%s%n", "RegressionTest1.test1000");
org.jsoup.helper.HttpConnection.Request request0 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method1 = request0.method();
org.jsoup.helper.HttpConnection.Request request2 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method3 = request2.method();
boolean boolean4 = request2.followRedirects;
org.jsoup.Connection.Request request6 = request2.followRedirects(true);
java.lang.String str8 = request2.header("null=hi!");
org.jsoup.helper.HttpConnection.Request request9 = new org.jsoup.helper.HttpConnection.Request();
org.jsoup.Connection.Method method10 = request9.method();
org.jsoup.Connection.Request request11 = request2.method(method10);
org.jsoup.Connection.Request request12 = request0.method(method10);
boolean boolean13 = request0.followRedirects;
boolean boolean14 = request0.ignoreContentType();
java.util.Map.Entry<java.lang.String, java.lang.String> strEntry16 = request0.scanHeaders("hi!=");
org.junit.Assert.assertTrue("'" + method1 + "' != '" + org.jsoup.Connection.Method.GET + "'", method1.equals(org.jsoup.Connection.Method.GET));
org.junit.Assert.assertTrue("'" + method3 + "' != '" + org.jsoup.Connection.Method.GET + "'", method3.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean4 + "' != '" + true + "'", boolean4 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request6);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(str8);
org.junit.Assert.assertTrue("'" + method10 + "' != '" + org.jsoup.Connection.Method.GET + "'", method10.equals(org.jsoup.Connection.Method.GET));
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request11);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNotNull(request12);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean13 + "' != '" + true + "'", boolean13 == true);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertTrue("'" + boolean14 + "' != '" + false + "'", boolean14 == false);
// Regression assertion (captures the current behavior of the code)
org.junit.Assert.assertNull(strEntry16);
}
}
| true |
ac47e652773e1addc8423ad5fdf08ba144ebe955 | Java | svantu/testFramework | /src/main/java/CommonUtilities/Utilities.java | UTF-8 | 5,822 | 2.515625 | 3 | [] | no_license | package CommonUtilities;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import org.apache.commons.io.FileUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Select;
import org.openqa.selenium.support.ui.Wait;
import org.openqa.selenium.support.ui.WebDriverWait;
public class Utilities {
WebDriver driver;
public static WebElement waitForAnElementUsingExplicit(WebDriver driver, By locator) {
WebDriverWait wait = new WebDriverWait(driver, 60);
wait.until(ExpectedConditions.presenceOfElementLocated(locator));
return driver.findElement(locator);
}
public static WebElement waitForElementUsingFluentWait(WebDriver driver, By locator) {
@SuppressWarnings("deprecation")
Wait<WebDriver> wait = new FluentWait<WebDriver>(driver).withTimeout(60, TimeUnit.SECONDS)
.ignoring(NoSuchElementException.class).pollingEvery(2, TimeUnit.SECONDS);
WebElement element = (WebElement) wait.until(new Function<WebDriver, WebElement>() {
@Override
public WebElement apply(WebDriver webDriver) {
// TODO Auto-generated method stub
return webDriver.findElement(locator);
}
});
return element;
}
public static void waitForStaleNessOfElementToGoOff(WebDriver driver, By locator) {
WebDriverWait wait = new WebDriverWait(driver, 60);
wait.until(ExpectedConditions.stalenessOf(driver.findElement(locator)));
}
public static boolean alertIsPresent(WebDriver driver) {
boolean isAlertPresent = false;
try {
driver.switchTo().alert();
isAlertPresent = true;
} catch (Exception e) {
// TODO: handle exception
}
return isAlertPresent;
}
public static String takeScreenShot(WebDriver driver, String DestinationPath) throws FileNotFoundException, IOException {
TakesScreenshot screenshot = ((TakesScreenshot) driver);
File srcFile = screenshot.getScreenshotAs(OutputType.FILE);
DestinationPath = DestinationPath + ".png";
File DestFileObj=new File(DestinationPath);
FileUtils.copyFile(srcFile, DestFileObj);
return DestinationPath;
}
public static WebElement customWait(WebDriver driver, By locator) throws InterruptedException {
for (int i = 0; i < 100; i++) {
try {
WebElement element = driver.findElement(locator);
if (element.isDisplayed()) {
break;
}
} catch (Exception e) {
Thread.sleep(500);
}
}
return driver.findElement(locator);
}
public static void selectAValueFromDropDownUsingVisibleText(WebDriver driver,String VisibleText,By locator) {
Select select=new Select(driver.findElement(locator));
select.selectByVisibleText(VisibleText);
}
public static void selectAVAlueFromDropDownUsingIndex(WebDriver driver,int index,By locator) {
Select select=new Select(driver.findElement(locator));
select.selectByIndex(index);
}
public static void selectAValueFRomDroDownUsingValue(WebDriver driver,String Value,By locator) {
Select select=new Select(driver.findElement(locator));
select.selectByValue(Value);
}
public static void mouseOver(WebDriver driver,WebElement element){
Actions actObj=new Actions(driver);
actObj.moveToElement(element).build().perform();
}
public static void dragAndDown(WebDriver driver,WebElement source,WebElement target) {
Actions actObj=new Actions(driver);
actObj.dragAndDrop(source, target).build().perform();
}
public static void switchToIFrame(WebDriver driver,WebElement element) {
driver.switchTo().frame(element);
}
public static void switchToWindow(WebDriver driver) {
String parentWindow=driver.getWindowHandle();
for(String window:driver.getWindowHandles()) {
if(!window.equals(parentWindow)) {
driver.switchTo().window(window);
}
}
}
public static void switchBetweenMultipleWindows(WebDriver driver,String PageTitle) {
Set<String> windows=driver.getWindowHandles();
for(String window:windows) {
driver.switchTo().window(window);
if(driver.getTitle().equalsIgnoreCase(PageTitle)) {
break;
}
}
}
public static void clickOnWebElement(WebDriver driver,By locator) {
driver.findElement(locator).click();
}
public static void sendTextIntoTextField(WebDriver driver,By locator,String text) {
driver.findElement(locator).sendKeys(text);
}
public static void clickAnElementUsingJavaScriptExecutor(WebDriver driver,WebElement element) {
((JavascriptExecutor) driver).executeScript("arguments[0].click();", element);
}
public static void asynchronousWaitUSingJavaScriptExecutor(WebDriver driver) {
((JavascriptExecutor) driver).executeAsyncScript("window.setTimeout(arguments[arguments.length - 1], 2000);");
}
public static void scrollToAnElementUsingJavaScriptExecutor(WebDriver driver,WebElement element) {
((JavascriptExecutor) driver).executeScript("arguments[0].scrollIntoView(true);", element);
}
public static void highlightAnElement(WebDriver driver,WebElement element) {
((JavascriptExecutor) driver).executeScript("arguments[0].style.background=\"pink\"", element);
}
public static String getAValueFromPropertyFile(String PropertyFileName,String Property) throws IOException {
Properties prop=new Properties();
FileInputStream fis=new FileInputStream(PropertyFileName+".properties");
prop.load(fis);
return prop.getProperty(Property);
}
}
| true |
84226714336f93b34737ea51d554ccf0da6eee5c | Java | tmathmeyer/email-calendar | /src/com/tmathmeyer/sentinel/ui/views/day/DayGridLabel.java | UTF-8 | 1,561 | 2.265625 | 2 | [] | no_license | /*******************************************************************************
* Copyright (c) 2013 WPI-Suite
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: Team YOCO (You Only Compile Once)
******************************************************************************/
package com.tmathmeyer.sentinel.ui.views.day;
import java.awt.Dimension;
import java.awt.GridLayout;
import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JPanel;
import com.tmathmeyer.sentinel.utils.Colors;
public class DayGridLabel extends JPanel
{
private static final long serialVersionUID = 1L;
public DayGridLabel()
{
this.setLayout(new GridLayout(24, 1));
this.setBackground(Colors.TABLE_BACKGROUND);
this.setPreferredSize(new Dimension(60, 1440));
this.setMaximumSize(new Dimension(60, 1440));
for (int i = 0; i < 24; i++)
{
int hour = i % 12 == 0 ? 12 : i % 12;
String padding = (hour < 10) ? " " : " ";
StringBuilder currtime = new StringBuilder();
currtime.append(" ").append(hour);
if (i <= 11)
currtime.append("am");
else
currtime.append("pm");
JLabel text = new JLabel(currtime.append(padding).toString());
text.setBackground(Colors.TABLE_BACKGROUND);
text.setBorder(BorderFactory.createMatteBorder(1, 1, i == 23 ? 1 : 0, 1, Colors.BORDER));
this.add(text);
}
}
}
| true |
991deabb80c1ce1b3cb0c7d05d3f22357992c434 | Java | RokeAbbey/xinmiao-project | /src/cn/edu/zucc/test/Test10.java | UTF-8 | 1,121 | 2.734375 | 3 | [] | no_license | package cn.edu.zucc.test;
import java.io.DataOutputStream;
public class Test10 {
static Thread t = null;
public static void main(String[] args) {
t = new Thread(){
DataOutputStream o = null;
@Override
public void run(){
System.out.println("line 8");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
try {
t = t.getClass().newInstance();
t.start();
} catch (InstantiationException | IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
t.start();
// try {
// t.join();
// t = t.getClass().newInstance();
// t.start();
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (InstantiationException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } catch (IllegalAccessException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
}
}
| true |
8eb0217d917f823c38a7985fa2d5233812178d3d | Java | CrazyStriker/Longest-Line-In-Polygon | /src/main/java/algorithms/airport/Utility.java | UTF-8 | 3,790 | 3.5 | 4 | [] | no_license | package algorithms.airport;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
public class Utility {
/**
* Calculates the angle from the src point to the destination point in degrees
*
* @param src src point
* @param dest dest point
* @return The angle in degrees
*/
public static double angleBetween(final Point2D src, final Point2D dest) {
return angleBetween(src.getX(), src.getY(), dest.getX(), dest.getY());
}
/**
* Calculates the angle from the src point to the destination point in degrees
*
* @param srcX src point x value
* @param srcY src point y value
* @param destX dest point x value
* @param destY dest point y value
* @return The angle in degrees
*/
public static double angleBetween(final double srcX, final double srcY, final double destX, final double destY) {
double dx = destX - srcX;
double dy = -(destY - srcY);
double inRads = Math.atan2(dy, dx);
if (inRads < 0)
inRads = Math.abs(inRads);
else
inRads = 2 * Math.PI - inRads;
return Math.toDegrees(inRads);
}
public static boolean isPointOnLine(final Line2D line, final Point2D pt) {
final double lineLength = line.getP1().distance(line.getP2());
final double sumOfPtDistance = line.getP1().distance(pt) + line.getP2().distance(pt);
final double epsilon = 0.00000000001;
return sumOfPtDistance + epsilon > lineLength && sumOfPtDistance - epsilon < lineLength;
}
/**
* Calculates the intersection point of two line segments
*
* @param a The first line
* @param b The second line
* @return The intersection point or NULL if the lines do not intersect
*/
public static Point2D getIntersection(final Line2D a, final Line2D b) {
double x = ((a.getX2() - a.getX1()) * (b.getX1() * b.getY2() - b.getX2() * b.getY1()) -
(b.getX2() - b.getX1()) * (a.getX1() * a.getY2() - a.getX2() * a.getY1()))
/ ((a.getX1() - a.getX2()) * (b.getY1() - b.getY2()) - (a.getY1() - a.getY2()) * (b.getX1() - b.getX2()));
double y = ((b.getY1() - b.getY2()) * (a.getX1() * a.getY2() - a.getX2() * a.getY1()) -
(a.getY1() - a.getY2()) * (b.getX1() * b.getY2() - b.getX2() * b.getY1()))
/ ((a.getX1() - a.getX2()) * (b.getY1() - b.getY2()) - (a.getY1() - a.getY2()) * (b.getX1() - b.getX2()));
double minXa = Math.min(a.getX1(), a.getX2());
double minXb = Math.min(b.getX1(), b.getX2());
double maxXa = Math.max(a.getX1(), a.getX2());
double maxXb = Math.max(b.getX1(), b.getX2());
double minYa = Math.min(a.getY1(), a.getY2());
double minYb = Math.min(b.getY1(), b.getY2());
double maxYa = Math.max(a.getY1(), a.getY2());
double maxYb = Math.max(b.getY1(), b.getY2());
// check that the intersection is within the domain and range of each line segment
if (x >= minXa && x >= minXb && x <= maxXa && x <= maxXb && y >= minYa && y >= minYb && y <= maxYa && y <= maxYb) {
return new Point2D.Double(x, y);
}
return null;
}
/**
* Checks if two line segments cross each other
*
* @param lineA The first line segment
* @param lineB The second line segment
* @return True if one line crosses the other
*/
public static boolean doLinesCross(final Line2D lineA, final Line2D lineB) {
if (!lineA.intersectsLine(lineB))
return false;
return !isPointOnLine(lineA, lineB.getP1()) && !isPointOnLine(lineA, lineB.getP2()) &&
!isPointOnLine(lineB, lineA.getP1()) && !isPointOnLine(lineB, lineA.getP2());
}
}
| true |
5d2a0ac6aaec7aabd2a4f809d6038bc263486e21 | Java | DSandi77/Final-Draft-DhruvSam | /src/ca_1/Movie.java | UTF-8 | 3,154 | 3.578125 | 4 | [] | no_license | package ca_1;
public class Movie {
private String title;
private int yearOfRelease;
private float runningTime;
private String genre;
private String plot;
// arrayList of actors in the movie
private ArrayList<Actor> actors;
private ArrayList<ActorWithMovie> characters;
public Movie(String title, int yearOfRelease, float runningTime, String genre, String plot) {
super();
this.title = title;
this.yearOfRelease = yearOfRelease;
this.runningTime = runningTime;
this.genre = genre;
this.plot = plot;
actors = new ArrayList<Actor>();
characters = new ArrayList<ActorWithMovie>();
}
public ArrayList<Actor> getActors() {
return actors;
}
public void setActors(ArrayList<Actor> actors) {
this.actors = actors;
}
public void addANewActorToMovie(String name, String dob, String gender, String nationality) {
actors.add(new Actor(name, dob, gender, nationality));
}
public ArrayList<ActorWithMovie> getCharacters() {
return characters;
}
public String getCharactersNames() {
return characters.toString();
}
public void setCharacters(ArrayList<ActorWithMovie> characters) {
this.characters = characters;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getYearOfRelease() {
return yearOfRelease;
}
public void setYearOfRelease(int yearOfRelease) {
this.yearOfRelease = yearOfRelease;
}
public float getRunningTime() {
return runningTime;
}
public void setRunningTime(float runningTime) {
this.runningTime = runningTime;
}
public String getGenre() {
return genre;
}
public void setGenre(String genre) {
this.genre = genre;
}
public String getPlot() {
return plot;
}
public void setPlot(String plot) {
this.plot = plot;
}
// public Image getPoster() {
// return poster;
// }
//
// public void setPoster(Image poster) {
// this.poster = poster;
// }
// adds actor to arrayList
public void addActorToMovie(Actor actor) {
actors.add(actor);
}
public void removeActorFromMovie(Actor actor) {
actors.remove(actor);
}
public void addCharacterToMovie(ActorWithMovie character) {
characters.add(character);
}
public void removeCharacterFromMovie(ActorWithMovie character) {
characters.remove(character);
}
public String printActors() {
String list = "";
// iterating over array
for (int i = 0; i < actors.size(); i++) {
list += actors.get(i).getName();
}
return list;
}
public String printCharacters() {
String list = "";
// iterating over array
for (int i = 0; i < actors.size(); i++) {
list += characters.get(i).getCharacter();
}
return list;
}
@Override
public String toString() {
return "Title = " + title +"\n"+
"Year Of Release = " + yearOfRelease +"\n"+
"Running Time =" + runningTime +"\n"+
"Genre = " + genre +"\n"+
"Plot =" + plot + "\n"+
"Actors = " + printActors() + "\n" + "Characters = " + getCharacters().toString();
}
} | true |
ec0a0c24bff7db8d5f55f566adb8d9ac9636fc27 | Java | a7217107/Leetcode | /xbj/src/Leetcode32.java | UTF-8 | 1,565 | 3.5625 | 4 | [] | no_license | import java.util.Stack;
/**
* ็ปๅฎไธไธชๅชๅ
ๅซ '('ย ๅ ')'ย ็ๅญ็ฌฆไธฒ๏ผๆพๅบๆ้ฟ็ๅ
ๅซๆๆๆฌๅท็ๅญไธฒ็้ฟๅบฆใ
* <p>
* ็คบไพย 1:
* <p>
* ่พๅ
ฅ: "(()"
* ่พๅบ: 2
* ่งฃ้: ๆ้ฟๆๆๆฌๅทๅญไธฒไธบ "()"
* ็คบไพ 2:
* <p>
* ่พๅ
ฅ: ")()())"
* ่พๅบ: 4
* ่งฃ้: ๆ้ฟๆๆๆฌๅทๅญไธฒไธบ "()()"
* <p>
* ๆฅๆบ๏ผๅๆฃ๏ผLeetCode๏ผ
* ้พๆฅ๏ผhttps://leetcode-cn.com/problems/longest-valid-parentheses
* ่ไฝๆๅฝ้ขๆฃ็ฝ็ปๆๆใๅไธ่ฝฌ่ฝฝ่ฏท่็ณปๅฎๆนๆๆ๏ผ้ๅไธ่ฝฌ่ฝฝ่ฏทๆณจๆๅบๅคใ
*/
public class Leetcode32 {
public static void main(String[] args) {
new Leetcode32().longestValidParentheses("()(()");
}
public int longestValidParentheses(String s) {
Stack<Character> stack = new Stack<>();
int max = 0;
int count = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (stack.empty() && c== ')') {
continue;
}
if (c == ')') {
if (stack.peek() == '(') {
stack.pop();
count++;
if (count << 1 > max) {
max = count << 1;
}
} else {
if (count << 1 > max) {
max = count << 1;
} else {
count = 0;
}
}
} else {
stack.push(c);
}
}
return max;
}
}
| true |
cd64b3dc0453b66ddd065a7a374885e24c408e1b | Java | abbystasja/Kickstarter | /src/com/kickstarter/view/QuestionAndAnswerView.java | UTF-8 | 794 | 2.59375 | 3 | [] | no_license | package com.kickstarter.view;
import com.kickstarter.controller.QuestionAndAnswerController;
import com.kickstarter.entities.Payment;
import com.kickstarter.entities.QuestionAndAnswer;
/**
* Created by akulygina on 5/28/2015.
*/
public class QuestionAndAnswerView extends View<QuestionAndAnswerController> {
public QuestionAndAnswerView(QuestionAndAnswerController controller) {
super(controller);
}
@Override
public void display() {
System.out.println("Enter your question");
String question = in.nextLine();
controller.addQuestionAndAnswer(new QuestionAndAnswer(question));
}
@Override
public int determineNextStep() {
System.out.println("Please enter 0 to go to your project");
return in.nextInt();
}
}
| true |
a765e741428b6e8d1fd9d8f07af70b02d455295c | Java | cocori89/andriod_gitproject | /helloworld/app/src/main/java/androidhome/helloworld/NewActivity.java | UTF-8 | 1,822 | 2.75 | 3 | [] | no_license | package androidhome.helloworld;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;
public class NewActivity extends AppCompatActivity {
/*์ ์ญ ๋ณ์*/
/*ํ
์คํธ๋ฅผ ๊ฐ์ ธ ์ค๋ ๊ฐ์ฒด*/
/*์๋์ผ๋ก EditText๋ฅผ ์ฐพ์์ ์ฐ๊ฒฐํด์ฃผ๋ ์ญํ ์ ํ๋ ๋ฏ ๋ณด์ */
EditText editText;
/*๋์ด๋ฅผ ์ฐพ์ ์ค๋ ๊ฐ์ฒด*/
EditText editText2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
/*activity_new.xml ํ์ผ์ ์ฝ๋๋ฅผ ๊ฐ์ ธ์์ java์ฝ๋๋ก ๋ฐ๊ฟ๋๋ ์ญํ ์ ํ๋ค. */
setContentView(R.layout.activity_new);
}
/*activity_main.xml์์ ๋ฒํผ์ ํด๋ฆญํ๊ฒ ๋๋ฉด ํธ์ถ๋๋ ํจ์ */
void onButtonShowMessageClicked(View v) {
/*xml์์ ์ฐพ์์ ๊ฐ์ ธ์์ผ ํ๋ค.*/
/*์๋ฐ ์คํฌ๋ฆฝํธ์ฒ๋ผ Id๋ฅผ ๊ฐ์ ธ ์ค๋ ๊ฒ์ฒ๋ผ ๊ฐ์ ธ ์ค๋ ๊ฒ์ด๋ค. */
/*์ด๋ฆ์ ๊ฐ์ ธ ์ค๋ ๊ฒ์ด๋ค. */
editText = findViewById(R.id.editText);
/*๋์ด์ ์์ด๋๋ฅผ ์ฐพ์์ ๊ฐ์ ธ ์จ๋ค. */
editText2 = findViewById(R.id.editText2);
/*๋ค์ด์ค๋ ๊ฐ์ฒด๊ฐ Objectํ์ด๊ธฐ ๋๋ฌธ์ text๋ฅผ ๊ฐ์ ธ ์จ ์ถ์ String ํ์ผ๋ก ๋ณํํด์ค๋ค. */
/*์ด๋ฆ์ String ํ์ผ๋ก ๋ณํํ๋ค.*/
String name =editText.getText().toString();
/*๋์ด๋ฅผ STring ํ์ผ๋ก ๋ณํ ํด์ ์ด๋ฆ ๋ค์ ๋ํด์๋ค. */
name =name+editText2.getText().toString();
/*Toast ๋ฉ์ธ์ง๋ฅผ ๋์ด์ค๋ค. */
Toast.makeText(getApplicationContext(), name+"์
๋๋ค.", Toast.LENGTH_LONG).show();
}
}
| true |
fd0d14702d7ccac02663c3832aff887570bed336 | Java | stubbsyy/GoogleTranslate | /MavenProject/src/main/framework/Driver.java | UTF-8 | 2,112 | 2.609375 | 3 | [] | no_license | import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class Driver {
WebDriver driver;
/*
* Constructor class for driver
*/
public Driver()
{
driver = null;
}
/*
* Driver for getting browser type and chrome driver
*/
public WebDriver getDriver(String browserType) {
if (browserType.equalsIgnoreCase("chrome"))
{
System.setProperty("webdriver.chrome.driver", System.getProperty("user.dir") + "/src/main/resources/ChromeDriver/v77/chromedriver.exe");
driver = new ChromeDriver();
}
return driver;
}
/*
* Set the google translated page
*/
public void getTranslatePage(String url) {
driver.get(url);
//return driver;
}
/*
* For clicking on an element by class name
*/
public void classNameClick(String classN) {
driver.findElement(By.className(classN)).click();
//return driver;
}
/*
* for clicking on an element by id name
*/
public WebDriver idNameClick(String idName) {
driver.findElement(By.id(idName)).click();
return driver;
}
/*
* for sending keys to id element
*/
public WebDriver idNameSendKey(String idName, String input) {
driver.findElement(By.id(idName)).sendKeys(input);
return driver;
}
/*
* for sending ENTER key to id element
*/
public WebDriver enterKeyId(String idName) {
driver.findElement(By.id(idName)).sendKeys(Keys.ENTER);
return driver;
}
/*
* to have page wait a certain length of time that is passed in
*/
public WebDriver timeOut(int length) {
driver.manage().timeouts().implicitlyWait(length, TimeUnit.SECONDS);
return driver;
}
/*
* Get inner text by class name if attribute is inntertext
*/
public String getAttribute(String id) {
String attribute = driver.findElement(By.className(id)).getAttribute("innerText");
return attribute;
}
/*
* Quit Chrome driver
*/
public void quit() {
driver.quit();
}
}
| true |
d43ed7a3b5554dadba719bfe5a003b247dd0ef50 | Java | xloc/ubc-cpen502 | /src/cc/xloc/ubc502/activation/BipolarSigmoidActivation.java | UTF-8 | 459 | 2.53125 | 3 | [] | no_license | package cc.xloc.ubc502.activation;
public class BipolarSigmoidActivation implements SigmoidLikeActivation {
@Override
public double f(double x) {
return -1 + 2.0 / (1 + Math.exp(-x));
}
@Override
public double dfdx(double x) {
double y = -1 + 2.0 / (1 + Math.exp(-x));
return 0.5 * (1 - Math.pow(y, 2));
}
@Override
public double dfdx_y(double y) {
return 0.5 * (1 - Math.pow(y, 2));
}
}
| true |
958209a3ec5bfac18099b92cf19d973cfab0b0d1 | Java | CountOn/JavaMail | /src/com/localhost/servlet/ResetPasswordServlet.java | UTF-8 | 2,834 | 2.4375 | 2 | [] | no_license | package com.localhost.servlet;
import java.io.IOException;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
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 com.localhost.service.UserService;
import com.localhost.service.Impl.UserServiceImpl;
import com.localhost.vo.User;
/**
* Servlet implementation class SetNewPasswordServlet
*/
@WebServlet("/SetNewPasswordServlet")
public class ResetPasswordServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public ResetPasswordServlet() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request, response);
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// ่ทๅๅ็ซฏ้กต้ขๅๆฐ
String userName = request.getParameter("userName");
String newPassword = request.getParameter("newPassword");
String newPassword2 = request.getParameter("newPassword2");
// ๆฐๆฎๆ ก้ช
Map<String,String> errors = new HashMap<String, String>();
if (newPassword == null || "".equals(newPassword)) {
errors.put("newPassword", "ๆฐๅฏ็ ไธ่ฝไธบ็ฉบ๏ผ");
}
if (newPassword2 == null || "".equals(newPassword2)) {
errors.put("newPassword2", "็กฎ่ฎคๆฐๅฏ็ ไธ่ฝไธบ็ฉบ๏ผ");
}
if (!newPassword.equals(newPassword2)) {
errors.put("passwordError", "ไธคๆฌก่พๅ
ฅ็ๅฏ็ ไธไธ่ด๏ผ");
}
if (!errors.isEmpty()) {
request.setAttribute("errors", errors);
request.getRequestDispatcher("/resetPassword.jsp?userName=" + userName).forward(request, response);
return;
}
// ๅฐ่ฃ
็จๆทๆฐๆฎ
User user = new User();
user.setUsername(userName);
user.setPassword(newPassword);
// ่ฆ้็ฝฎๅฏ็
UserService service = new UserServiceImpl();
try {
service.resetPassword(user);
} catch (SQLException e) {
e.printStackTrace();
}
// ้กต้ข่ทณ่ฝฌ
request.getRequestDispatcher("/index.jsp").forward(request, response);
}
}
| true |
502e26a1f4e432f350940c8c3ef6e8af16b3166f | Java | hannkeat/Appium | /src/com/automationlearning/Tutorial14.java | UTF-8 | 1,449 | 2.453125 | 2 | [] | no_license | /**
*
*/
package com.automationlearning;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.remote.DesiredCapabilities;
import io.appium.java_client.AppiumDriver;
import io.appium.java_client.MobileElement;
import io.appium.java_client.android.AndroidDriver;
/**
* @author CHIRAG
*
*/
public class Tutorial14 {
AppiumDriver<MobileElement> driver;
public void setUp() throws MalformedURLException
{
DesiredCapabilities cap = new DesiredCapabilities();
cap.setCapability("platformName", "Android");
cap.setCapability("deviceName", "Moto G");
cap.setCapability("browserName", "Chrome");
driver = new AndroidDriver<MobileElement>(new URL("http://0.0.0.0:4723/wd/hub"), cap);
driver.get("http://www.google.com");
driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
}
public void searchKeyword() throws InterruptedException
{
driver.findElementByName("q").sendKeys("appium");
Thread.sleep(5000);
}
public void tearDown()
{
driver.quit();
}
/**
* @param args
* @throws MalformedURLException
* @throws InterruptedException
*/
public static void main(String[] args) throws MalformedURLException, InterruptedException {
// TODO Auto-generated method stub
Tutorial14 obj = new Tutorial14();
obj.setUp();
obj.searchKeyword();
obj.tearDown();
}
}
| true |
efaa2dbf5e0b6db290cdcac5dc518337a1acc50e | Java | huanfion/Storeage-microservices | /storage-product/src/main/java/com/zegobird/product/entity/Productinfo.java | UTF-8 | 4,129 | 1.828125 | 2 | [] | no_license | package com.zegobird.product.entity;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.annotation.*;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* <p>
* ไบงๅไฟกๆฏ
* </p>
*
* @author huanfion
* @since 2019-09-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("tb_productinfo")
public class Productinfo extends Model<Productinfo> {
private static final long serialVersionUID=1L;
/**
* ไบงๅID
*/
@TableId(type = IdType.AUTO)
private Long productid;
/**
* ไบงๅ็ผๅท๏ผSPU๏ผ
*/
private String productcode;
/**
* ไบงๅๆก็
*/
private String productbarcode;
/**
* ไบงๅๅ็งฐ
*/
private String productname;
/**
* ๅ็ฑปID
*/
private Integer typeid;
/**
* ๅ็ฑปๅ็งฐ
*/
private String typename;
/**
* ๅฎๅ
จ่ทฏๅพId
*/
private String fulltypeid;
/**
* ๅฎๆ่ทฏๅพ
*/
private String fulltypename;
/**
* ๅไฝId
*/
private Integer unitid;
/**
* ๅไฝๅ็งฐ
*/
private String unitname;
/**
* ไพๅบๅId
*/
private Integer supplierid;
/**
* ไพๅบๅๅ็งฐ
*/
private String suppliername;
/**
* ่ดงไธปID
*/
private Integer consignorid;
/**
* ่ดงไธป็ผๅท
*/
private String consignorcode;
/**
* ่ดงไธปๅ็งฐ
*/
private String consignorname;
/**
* ๅ็ID
*/
private Integer brandid;
/**
* ๅ็ๅ็งฐ
*/
private String brandname;
/**
* ๅๅไธปๅพ ๏ผๅๅไธปๅพ็ๆฏjsonๆนๅผๅญๅจ๏ผๆ ผๅผ๏ผ
[{"FileName": "123456","FilePath": "/ProductImg/123456.jpg"} ]
FileNameๆฏๆไปถๅ๏ผFilePathๆฏๅพ็ๅฐๅ๏ผ
*/
private JSONArray productimage;
/**
* ้่ดญไปท
*/
private BigDecimal purchaseprice;
/**
* ๆๆฌไปท
*/
private BigDecimal costprice;
/**
* ้ๅฎไปท
*/
private BigDecimal saleprice;
/**
* ้ขๅฎ ๏ผ0 ๅฆ 1 ๆฏ๏ผ
*/
private Integer presell;
/**
* ็ถๆ (1 ๆญฃๅธธ 0 ็ฆ็จ)
*/
private Integer state;
/**
* ๆฏๅฆๅผๅฏ่งๆ ผ (0 ๅ
ณ้ญ 1 ๅผๅฏ)
*/
private Integer isopen;
/**
* ๆๅบๅท
*/
private Integer orderno;
/**
* ๅๅปบไบบ
*/
@TableField(fill = FieldFill.INSERT)
private Integer createid;
/**
* ๅๅปบไบบ
*/
@TableField(fill = FieldFill.INSERT)
private String creator;
/**
* ๅๅปบๆถ้ด
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createdate;
/**
* ไฟฎๆนไบบID
*/
@TableField(fill = FieldFill.UPDATE)
private Integer modifyid;
/**
* ไฟฎๆนไบบ
*/
@TableField(fill = FieldFill.UPDATE)
private String modifier;
/**
* ไฟฎๆนๆถ้ด
*/
@TableField(fill = FieldFill.UPDATE)
private LocalDateTime modifydate;
/**
* ่ดงๅธId
*/
@TableField("currencyid")
private Integer currencyid;
/**
* ่ดงๅธ
*/
private String currency;
/**
* ๆฏๅฆไฟ่ดจๆ
*/
private Integer isexpiration;
/**
* ไฟ่ดจๆๅคฉๆฐ
*/
private Integer expirationnum;
/**
* ็ฆๆถๆถๆ
*/
private Integer limitationofreceipt;
/**
* ็ฆๅฎๆถๆ
*/
private Integer limitationofsales;
/**
* ้ข่ญฆๅคฉๆฐ
*/
private Integer warningdays;
/**
* ๆฏๅฆ่ดจๆฃ
*/
private Integer qualitycontrol;
/**
* ๆฏๅฆๆซๆๆก็
*/
private Integer scanbarcode;
/**
* ่ดจๆฃๆนๆฌกๅฑๆง
*/
private JSONArray batchattr;
@Override
protected Serializable pkVal() {
return this.productid;
}
}
| true |
1a422fc93d5a9702f9c1288f0517dda6cd87b95d | Java | DevikaS/gdam | /Core/src/com/adstream/automate/babylon/JsonObjects/ordering/enums/AdbankLevel.java | UTF-8 | 608 | 2.46875 | 2 | [] | no_license | package com.adstream.automate.babylon.JsonObjects.ordering.enums;
/**
* Created with IntelliJ IDEA.
* User: demidovskiy-r
* Date: 21.10.13
* Time: 13:12
*/
public enum AdbankLevel {
None(0, "None"),
AdbankLite(1, "Adbank Lite"),
AdbankStandard(2, "Adbank Standard"),
AdbankPlus(3, "Adbank Plus"),
AdbankPro(4, "Adbank Pro");
private Integer key;
private String name;
private AdbankLevel(int key, String name) {
this.key = key;
this.name = name;
}
@Override
public String toString() {
return name;
}
} | true |
b36738038d8b0b48abd7033f119dd1c2bb94578e | Java | fm00110/eclipse-pro | /myrabbit/src/main/java/com/ncu/util/ConnectionUtil.java | UTF-8 | 793 | 2.546875 | 3 | [] | no_license | package com.ncu.util;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class ConnectionUtil {
/**
*
* ่ทๅMQ็่ฟๆฅ
* @throws Exception
* @throws IOException
*
*/
public static Connection getConnection() throws IOException, Exception {
ConnectionFactory factory = new ConnectionFactory();
//่ฎพ็ฝฎไธปๆบ
factory.setHost("192.168.36.129");
//่ฎพ็ฝฎ็ซฏๅฃๅท๏ผๅฎขๆท็ซฏ็ๆฏ5672๏ผ็ฎก็็ซฏๅฃๆฏ15672
factory.setPort(5672);
//่ฎพ็ฝฎ็จๆทๅๅๅฏ็
factory.setUsername("guest");
factory.setPassword("guest");
//่ฎพ็ฝฎVhost
factory.setVirtualHost("/");
//่ทๅ่ฟๆฅ
return factory.newConnection();
}
}
| true |
d4acd92c9fcf637b121f41db457408928f598ecb | Java | unknownME/RestAssured_me | /src/main/java/DynamicJson.java | UTF-8 | 1,053 | 2.265625 | 2 | [] | no_license | package main.java;
import files.PayLoad;
import files.ReusableMethods;
import io.restassured.RestAssured;
import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static io.restassured.RestAssured.given;
public class DynamicJson {
@Test(dataProvider = "BooksData")
public void test(String isbn, String aisle) {
RestAssured.baseURI = "http://216.10.245.166";
Response r = given().
header("Content-Type", "application/json").
body(PayLoad.addBook(isbn, aisle)).
when().
post("/Library/Addbook.php")
.then().assertThat().statusCode(200).extract().response();
// JsonPath js = ReusableMethods.rawToJSON(r);
// System.out.println(js.get("ID"));
}
@DataProvider(name = "BooksData")
public Object[][] getData() {
return new Object[][]{{"asdfa1", "9991"}, {"asdfs1", "8881"}, {"asdfd1", "7771"}};
}
}
| true |
1e781311d0d5c6ed0edf89eb3b3cf7b8620bb60f | Java | davidleen/TeamViewProject | /app/src/main/java/com/david/teamviewproject/MainActivity.java | UTF-8 | 856 | 2.03125 | 2 | [] | no_license | package com.david.teamviewproject;
import java.util.ArrayList;
import android.app.Activity;
import android.os.Bundle;
import android.widget.Toast;
import com.david.teamviewproject.TeamView.OnItemClickListener;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TeamView tv = (TeamView) this.findViewById(R.id.teamView);
DataAdapter da = new DataAdapter(this, new ArrayList<TeamData>());
da.initFewDatas();
tv.setAdapter(da);
tv.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(int position, Object data) {
Toast.makeText(MainActivity.this, "data:" + data + ",position:" + position, Toast.LENGTH_SHORT).show();
}
});
// f4;
}
}
| true |
b2edd624d0c220becd47d866e92f1c752af5f9ea | Java | caspervg/aggr | /src/test/java/net/caspervg/aggr/worker/read/CsvAggrReaderTests.java | UTF-8 | 2,132 | 2.15625 | 2 | [
"MIT"
] | permissive | package net.caspervg.aggr.worker.read;
import com.google.common.collect.Iterables;
import net.caspervg.aggr.core.bean.Measurement;
import net.caspervg.aggr.ext.TimedGeoMeasurement;
import net.caspervg.aggr.core.util.AggrContext;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public class CsvAggrReaderTests {
private AggrContext ctx;
private CsvAggrReader reader;
@Before
public void initialize() {
Map<String, String> params = new HashMap<>();
params.put("id_key", "identifier");
params.put("source_key", "parent_column");
params.put("input_path", CsvAggrReaderTests.class.getResource("/measurements.csv").getPath());
ctx = AggrContext.builder().parameters(params).inputClass(TimedGeoMeasurement.class).build();
reader = new CsvAggrReader(new BufferedReader(new InputStreamReader(CsvAggrReader.class.getResourceAsStream("/measurements.csv"))));
}
@Test
public void readOneExistsTest() {
Optional<Measurement> possibleMeasurement = reader.read("measurement_4", ctx);
Assert.assertTrue(possibleMeasurement.isPresent());
Measurement meas = possibleMeasurement.get();
Assert.assertEquals("measurement_4", meas.getUuid());
Assert.assertArrayEquals(new Double[]{50.4,4.4}, meas.getVector());
Assert.assertEquals(Optional.of(LocalDateTime.parse("2015-09-10T08:47:39")), meas.getTimestamp());
}
@Test
public void readOneNotExistsTest() {
Optional<Measurement> possibleMeasurement = reader.read("measurement_unavailable", ctx);
Assert.assertFalse(possibleMeasurement.isPresent());
}
@Test
public void readAllTest() {
Iterable<Measurement> measurements = reader.read(ctx);
Assert.assertNotNull(measurements);
Measurement[] measArr = Iterables.toArray(measurements, Measurement.class);
Assert.assertEquals(4, measArr.length);
}
}
| true |
5f0fc42ced07c0b25f5d5d0b6ffd38fe78974a41 | Java | mahayash315/NitechBBSrv | /app/models/response/api/bbanalyzer/ClassifyItemResponse.java | UTF-8 | 266 | 1.851563 | 2 | [] | no_license | package models.response.api.bbanalyzer;
public class ClassifyItemResponse extends BBAnalyzerResponse {
public Integer clazz;
public ClassifyItemResponse() {
super();
}
public ClassifyItemResponse(BBAnalyzerResponse base) {
super(base);
}
}
| true |
cd6ef16f855d7ba1724e9d66496060cab7803e18 | Java | fatcorn/demo | /sharddingsphere-demo/src/main/java/com/den/sdsdemo/service/impl/Table2ServiceImpl.java | UTF-8 | 1,410 | 2.140625 | 2 | [] | no_license | package com.den.sdsdemo.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.den.sdsdemo.entity.Table2;
import com.den.sdsdemo.mapper.Table2Mapper;
import com.den.sdsdemo.service.ITable2Service;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author fatKarin
* @since 2020-02-27
*/
@Service
public class Table2ServiceImpl extends ServiceImpl<Table2Mapper, Table2> implements ITable2Service {
@Override
public void batchAdd() {
Table2 table2 = new Table2();
table2.setColumn2("default");
table2.setColumn3("default");
table2.setColumn4("default");
table2.setColumn5("default");
table2.setColumn6("default");
table2.setCreateTime(new Date());
ExecutorService executorService = Executors.newFixedThreadPool(30);
Thread task = new Thread(() ->{
int i = 10000;
while ( i-- > 0) {
this.save(table2);
table2.setId(null);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
for (int i = 0; i < 30; i++) {
executorService.submit(task);
}
}
}
| true |
8dcf9e21cc9b1a96cdd3d060345ca2ecd5235eba | Java | RaayTorres/Coaching | /CoachingSpring/src/main/java/pdg/dto/mapper/TipoDocumentoMapper.java | UTF-8 | 3,231 | 2.125 | 2 | [] | no_license | package pdg.dto.mapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import pdg.modelo.*;
import pdg.modelo.TipoDocumento;
import pdg.modelo.dto.TipoDocumentoDTO;
import pdg.modelo.logic.*;
import java.util.ArrayList;
import java.util.List;
/**
* @author Zathura Code Generator http://zathuracode.org
* www.zathuracode.org
*
*/
@Component
@Scope("singleton")
public class TipoDocumentoMapper implements ITipoDocumentoMapper {
private static final Logger log = LoggerFactory.getLogger(TipoDocumentoMapper.class);
@Transactional(readOnly = true)
public TipoDocumentoDTO tipoDocumentoToTipoDocumentoDTO(
TipoDocumento tipoDocumento) throws Exception {
try {
TipoDocumentoDTO tipoDocumentoDTO = new TipoDocumentoDTO();
tipoDocumentoDTO.setIdDoc(tipoDocumento.getIdDoc());
tipoDocumentoDTO.setTdocNombre((tipoDocumento.getTdocNombre() != null)
? tipoDocumento.getTdocNombre() : null);
return tipoDocumentoDTO;
} catch (Exception e) {
throw e;
}
}
@Transactional(readOnly = true)
public TipoDocumento tipoDocumentoDTOToTipoDocumento(
TipoDocumentoDTO tipoDocumentoDTO) throws Exception {
try {
TipoDocumento tipoDocumento = new TipoDocumento();
tipoDocumento.setIdDoc(tipoDocumentoDTO.getIdDoc());
tipoDocumento.setTdocNombre((tipoDocumentoDTO.getTdocNombre() != null)
? tipoDocumentoDTO.getTdocNombre() : null);
return tipoDocumento;
} catch (Exception e) {
throw e;
}
}
@Transactional(readOnly = true)
public List<TipoDocumentoDTO> listTipoDocumentoToListTipoDocumentoDTO(
List<TipoDocumento> listTipoDocumento) throws Exception {
try {
List<TipoDocumentoDTO> tipoDocumentoDTOs = new ArrayList<TipoDocumentoDTO>();
for (TipoDocumento tipoDocumento : listTipoDocumento) {
TipoDocumentoDTO tipoDocumentoDTO = tipoDocumentoToTipoDocumentoDTO(tipoDocumento);
tipoDocumentoDTOs.add(tipoDocumentoDTO);
}
return tipoDocumentoDTOs;
} catch (Exception e) {
throw e;
}
}
@Transactional(readOnly = true)
public List<TipoDocumento> listTipoDocumentoDTOToListTipoDocumento(
List<TipoDocumentoDTO> listTipoDocumentoDTO) throws Exception {
try {
List<TipoDocumento> listTipoDocumento = new ArrayList<TipoDocumento>();
for (TipoDocumentoDTO tipoDocumentoDTO : listTipoDocumentoDTO) {
TipoDocumento tipoDocumento = tipoDocumentoDTOToTipoDocumento(tipoDocumentoDTO);
listTipoDocumento.add(tipoDocumento);
}
return listTipoDocumento;
} catch (Exception e) {
throw e;
}
}
}
| true |
9e3303f81ee697f46bd54df4e796d9486a91ec0c | Java | SunnyRan/LeetCodeOJ | /src/main/java/com/java/StreamTest.java | UTF-8 | 2,239 | 2.953125 | 3 | [] | no_license | package com.java;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;
/**
* @program: LeetCodeOJ
* @description:
* @author: Arnold
* @create: 2019-07-30 16:51
**/
public class StreamTest {
public static int round = 1000;
public ExecutorService executor = Executors.newFixedThreadPool(1000);
List<Future<Integer>> futures = new ArrayList<>();
List re = new ArrayList();
List<Integer> test = new ArrayList();
public static void main(String[] args) {
StreamTest test = new StreamTest();
test.getTestList();
Long start =System.currentTimeMillis();
// test.testFuture();
// test.testStream();
test.testParallelStream();
Long end = System.currentTimeMillis();
System.out.println("spend time :"+ ( end - start));
}
public void testFuture(){
for (int i=0; i<test.size(); i++ ){
int finalI = i;
Callable<Integer> callable = ()-> this.doSomething(test.get(finalI));
Future<Integer> future = executor.submit(callable);
futures.add(future);
}
for (Future<Integer> future:futures){
try {
Integer segmentRs = future.get();
re.add(segmentRs);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (ExecutionException e) {
}
}
// System.out.println(re);
executor.shutdown();
}
public void testStream(){
test.stream().forEach(info->re.add(doSomething(info)));
// System.out.println(re);
}
public void testParallelStream(){
test.parallelStream().forEach(info->re.add(doSomething(info)));
// System.out.println(re);
}
public void getTestList(){
for(int i = 0;i<round;i++){
test.add(i+10);
}
}
public Integer doSomething (Integer i){
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
return new Random().nextInt(i);
}
}
| true |
c735e423e03a7ddd3282092965d58d7248ee3048 | Java | Dr-wgy/hh | /mc-core/src/main/java/com/makenv/model/mc/core/config/UserDataDir.java | UTF-8 | 1,999 | 1.953125 | 2 | [] | no_license | package com.makenv.model.mc.core.config;
/**
* Created by wgy on 2017/2/28.
*/
public class UserDataDir {
private String dirPath;
private UserGeogrid geogrid;
private Globaldatasets globaldatasets;
private Griddesc griddesc;
private OceanFile ocean;
public String getDirPath() {
return dirPath;
}
public void setDirPath(String dirPath) {
this.dirPath = dirPath;
}
public Griddesc getGriddesc() {
return griddesc;
}
public void setGriddesc(Griddesc griddesc) {
this.griddesc = griddesc;
}
public UserGeogrid getGeogrid() {
return geogrid;
}
public void setGeogrid(UserGeogrid geogrid) {
this.geogrid = geogrid;
}
public Globaldatasets getGlobaldatasets() {
return globaldatasets;
}
public void setGlobaldatasets(Globaldatasets globaldatasets) {
this.globaldatasets = globaldatasets;
}
public OceanFile getOcean() {
return ocean;
}
public void setOcean(OceanFile ocean) {
this.ocean = ocean;
}
public static class UserGeogrid {
public String getDirPath() {
return dirPath;
}
public void setDirPath(String dirPath) {
this.dirPath = dirPath;
}
private String dirPath;
}
public static class Griddesc {
private String dirPath;
private String filePath;
public String getDirPath() {
return dirPath;
}
public void setDirPath(String dirPath) {
this.dirPath = dirPath;
}
public String getFilePath() {
return filePath;
}
public void setFilePath(String filePath) {
this.filePath = filePath;
}
}
public static class OceanFile {
private String dirPath;
private String filePath;
public String getDirPath() {
return dirPath;
}
public void setDirPath(String dirPath) {
this.dirPath = dirPath;
}
public String getFilePath() {
return filePath;
}
public void setFilePath(String filePath) {
this.filePath = filePath;
}
}
}
| true |
4335c2a9b59af5a04ed73b064adbc9225c41b457 | Java | sandormiko/gb-calculator | /src/main/java/com/gb/calculator/business/validation/CalculationValidator.java | UTF-8 | 3,457 | 2.625 | 3 | [] | no_license | package com.gb.calculator.business.validation;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.stereotype.Component;
import com.gb.calculator.business.dto.CalculationValidorInput;
import com.gb.calculator.business.resources.CalculatorMessageResources;
@Component
public class CalculationValidator {
public CalculationValidationResult validate(CalculationValidorInput calculation) {
CalculationValidationResult result = new CalculationValidationResult();
String feedbackMsg = validateVatRate(calculation);
if (!StringUtils.isEmpty(feedbackMsg)) {
result.getFeedbackMessages().add(feedbackMsg);
}
feedbackMsg = validateAmounts(calculation);
if (!StringUtils.isEmpty(feedbackMsg)) {
result.getFeedbackMessages().add(feedbackMsg);
}
return result;
}
private String validateVatRate(CalculationValidorInput calculation) {
String vatRate = calculation.getVatRate();
String feedBackMessage = null;
if(StringUtils.isEmpty(vatRate)){
feedBackMessage = CalculatorMessageResources.VAT_RATE_IS_MISSING;
}else if (!NumberUtils.isNumber(vatRate)) {
feedBackMessage = CalculatorMessageResources.VAT_RATE_NOT_NUMERIC;
} else if (Integer.valueOf(vatRate) <= 0) {
feedBackMessage = CalculatorMessageResources.VAT_RATE_ZERO;
}
return feedBackMessage;
}
private String validateAmounts(CalculationValidorInput calculation) {
String feedBackMessage = null;
String priceIncVat = calculation.getPriceInclVat();
String priceWoVat = calculation.getPriceWoVat();
String valueAddedTax = calculation.getValueAddedTax();
feedBackMessage = checkOnlyOneAmountIsGiven(calculation);
if (StringUtils.isNotEmpty(feedBackMessage)) {
return feedBackMessage;
}
if (StringUtils.isNotEmpty(priceIncVat) && !NumberUtils.isNumber(priceIncVat)) {
feedBackMessage = CalculatorMessageResources.PRINCE_INC_VAT_NOT_NUMERIC;
} else if (StringUtils.isNotEmpty(priceWoVat) && !NumberUtils.isNumber(priceWoVat)) {
feedBackMessage = CalculatorMessageResources.PRINCE_WO_VAT_NOT_NUMERIC;
} else if (StringUtils.isNotEmpty(valueAddedTax) && !NumberUtils.isNumber(valueAddedTax)) {
feedBackMessage = CalculatorMessageResources.VALUE_ADDED_TAX_NOT_NUMERIC;
} else if (StringUtils.isNotEmpty(priceIncVat) && Double.valueOf(priceIncVat) <= 0) {
feedBackMessage = CalculatorMessageResources.PRICE_INCL_VAT_ZERO;
} else if (StringUtils.isNotEmpty(priceWoVat) && Double.valueOf(priceWoVat) <= 0) {
feedBackMessage = CalculatorMessageResources.PRICE_WO_VAT_ZERO;
} else if (StringUtils.isNotEmpty(valueAddedTax) && Double.valueOf(valueAddedTax) <= 0) {
feedBackMessage = CalculatorMessageResources.VALUE_ADDED_TAX_ZERO;
}
return feedBackMessage;
}
private String checkOnlyOneAmountIsGiven(CalculationValidorInput calculation) {
String feedBackMessage = null;
String priceIncVat = calculation.getPriceInclVat();
String priceWoVat = calculation.getPriceWoVat();
String valueAddedTax = calculation.getValueAddedTax();
int count = 0;
if (StringUtils.isNotEmpty(priceIncVat)) {
count++;
}
if (StringUtils.isNotEmpty(priceWoVat)) {
count++;
}
if (StringUtils.isNotEmpty(valueAddedTax)) {
count++;
}
if (count == 0) {
feedBackMessage = CalculatorMessageResources.NO_AMOUNT;
} else if (count > 1) {
feedBackMessage = CalculatorMessageResources.TOO_MANY_AMOUNTS;
}
return feedBackMessage;
}
}
| true |
c9e9bfbe6bd3880f900ebe8ac7f3bf194ce416a0 | Java | heaven6059/wms | /logistics-wms-city-1.1.3.44.5/logistics-wms-city-service/src/main/java/com/yougou/logistics/city/service/BillOmCheckWeightServiceImpl.java | UTF-8 | 763 | 1.90625 | 2 | [] | no_license | package com.yougou.logistics.city.service;
import com.yougou.logistics.base.dal.database.BaseCrudMapper;
import com.yougou.logistics.base.service.BaseCrudServiceImpl;
import com.yougou.logistics.city.dal.mapper.BillOmCheckWeightMapper;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
/**
*
* ็งฐ้serviceๅฎ็ฐ
*
* @author qin.dy
* @date 2013-9-29 ไธๅ9:35:50
* @version 0.1.0
* @copyright yougou.com
*/
@Service("billOmCheckWeightService")
class BillOmCheckWeightServiceImpl extends BaseCrudServiceImpl implements BillOmCheckWeightService {
@Resource
private BillOmCheckWeightMapper billOmCheckWeightMapper;
@Override
public BaseCrudMapper init() {
return billOmCheckWeightMapper;
}
} | true |
c900a7a856211b47ea4c0f563e565e2569ab5c7f | Java | mathmferreira/Treinamento | /src/main/java/br/com/treinamento/ultracar/Treinamento/repositorios/impl/CustomizedMenuRepositoryImpl.java | UTF-8 | 775 | 2.09375 | 2 | [] | no_license | package br.com.treinamento.ultracar.Treinamento.repositorios.impl;
import java.util.HashMap;
import java.util.Map;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import br.com.treinamento.ultracar.Treinamento.entidades.Menu;
import br.com.treinamento.ultracar.Treinamento.repositorios.CustomizedMenuRepository;
public class CustomizedMenuRepositoryImpl implements CustomizedMenuRepository {
@PersistenceContext
private EntityManager manager;
@Override
public Page<Menu> findByFilter(Menu menu, Pageable pageable) {
StringBuilder jpql = new StringBuilder();
Map<String, Object> parameters = new HashMap<>();
return null;
}
}
| true |
5e0ea7da95df30a978c4b93e0fbe31524ee16950 | Java | emperwang/JavaBase | /LeeCode/src/main/java/com/wk/numer/SwapNumber.java | UTF-8 | 554 | 3.171875 | 3 | [] | no_license | package com.wk.numer;
/**
* @author: Sparks
* @Date: 2021/3/13 17:21
* @Description
*/
public class SwapNumber {
/*
ไธๅๅฉ็ฌฌไธๆนๅ้ ๆฅไบคๆขไธคไธชๅ้็ๅผ
*/
public void swapPlus(int a, int b){
a += b;
b = a - b;
a = a - b;
}
public void swapMulti(int a, int b){
a = a * b;
b = a / b;
a = a/ b;
}
public void swapByte(int a, int b){
a = a ^ b;
b = a ^ b;
a = a^b;
}
public static void main(String[] args) {
}
}
| true |
e69af87b1f9f79169db8850e1274dc9e3761ed17 | Java | BenZeher/SMCP | /ServiceManager/src/smfa/FATransactionListSelect.java | UTF-8 | 12,633 | 1.671875 | 2 | [] | no_license | package smfa;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Calendar;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import smcontrolpanel.SMAuthenticate;
import smcontrolpanel.SMSystemFunctions;
import smcontrolpanel.SMUtilities;
import ConnectionPool.WebContextParameters;
import SMDataDefinition.SMTablelocations;
import ServletUtilities.clsServletUtilities;
import ServletUtilities.clsCreateHTMLTableFormFields;
import ServletUtilities.clsDatabaseFunctions;
import ServletUtilities.clsManageRequestParameters;
public class FATransactionListSelect extends HttpServlet {
private static final long serialVersionUID = 1L;
public static final String LOCATION_PARAMETER = "LOCATION";
public static final String SHOWALLLOCATIONS_PARAMETER = "SHOWALLLOCATIONS";
public static final String GROUPBY_PARAMETER = "GROUPBY";
public static final String GROUPBY_VALUE_CLASS = "GROUPBYCLASS";
public static final String GROUPBY_VALUE_GL = "GROUPBYGL";
private static final String CHECKBOX_LABEL = "CHECKBOXLABEL";
//private static String sObjectName = "Asset";
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
//Get the session info:
HttpSession CurrentSession = request.getSession(true);
String sCalledClassName = "FATransactionListGenerate";
String sCompanyName = (String) CurrentSession.getAttribute(SMUtilities.SMCP_SESSION_PARAM_COMPANYNAME);
String sDBID = (String) CurrentSession.getAttribute(SMUtilities.SMCP_SESSION_PARAM_DATABASE_ID);
String sUserName = (String) CurrentSession.getAttribute(SMUtilities.SMCP_SESSION_PARAM_USERNAME);
if (!SMAuthenticate.authenticateSMCPCredentials(request, response, getServletContext(), SMSystemFunctions.FATransactionReport)){
return;
}
String title = "Transaction List for " + sCompanyName;
String subtitle = "";
out.println(SMUtilities.SMCPTitleSubBGColor(title, subtitle, SMUtilities.getInitBackGroundColor(getServletContext(), sDBID), sCompanyName));
out.println(SMUtilities.getDatePickerIncludeString(getServletContext()));
//If there is a warning from trying to input previously, print it here:
String sWarning = clsManageRequestParameters.get_Request_Parameter("Warning", request);
if (! sWarning.equalsIgnoreCase("")){
out.println("<B><FONT COLOR=\"RED\">WARNING: " + sWarning + "</FONT></B><BR>");
}
String sStatus = clsManageRequestParameters.get_Request_Parameter("Status", request);
if (! sStatus.equalsIgnoreCase("")){
out.println("<B>STATUS: " + sStatus + "</B><BR>");
}
//Print a link to the first page after login:
out.println("<BR><A HREF=\"" + SMUtilities.getURLLinkBase(getServletContext()) + "smcontrolpanel.SMUserLogin?"
+ SMUtilities.SMCP_REQUEST_PARAM_DATABASE_ID + "=" + sDBID
+ "\">Return to user login</A><BR>");
out.println("<A HREF=\"" + SMUtilities.getURLLinkBase(getServletContext()) + "smfa.FAMainMenu?"
+ SMUtilities.SMCP_REQUEST_PARAM_DATABASE_ID + "=" + sDBID
+ "\">Return to Fixed Assets Main Menu</A><BR>");
out.println("<A HREF=\"" + WebContextParameters.getdocumentationpageURL(getServletContext()) + "#" + Long.toString(SMSystemFunctions.FATransactionReport)
+ "\">Summary</A><BR><BR>");
out.println("<FORM NAME='MAINFORM' ACTION='" + SMUtilities.getURLLinkBase(getServletContext()) + "smfa." + sCalledClassName + "' METHOD='POST'>");
out.println("<INPUT TYPE=HIDDEN NAME='" + SMUtilities.SMCP_REQUEST_PARAM_DATABASE_ID + "' VALUE='" + sDBID + "'>");
out.println("<INPUT TYPE=HIDDEN NAME=CallingClass VALUE=\"" + this.getClass().getName() + "\">");
try{
List_Criteria(out, sDBID, sUserName, request);
}catch (Exception e){
response.sendRedirect(
"" + SMUtilities.getURLLinkBase(getServletContext()) + "smfa.FAMainMenu"
+ "?Warning=" + clsServletUtilities.URLEncode("Error displaying period end criteria selecting screen : " + e.getMessage())
+ "&" + SMUtilities.SMCP_REQUEST_PARAM_DATABASE_ID + "=" + sDBID
);
return;
}
out.println("</FORM>");
out.println ("<NOSCRIPT>\n"
+ " <font color=red>\n"
+ " <H3>This page requires that JavaScript be enabled to function properly</H3>\n"
+ " </font>\n"
+ "</NOSCRIPT>\n"
+ "<script type=\"text/javascript\">\n"
+ "function confirmation(){\n"
+ " var ProvisionalCheck = document.getElementById('PROVISIONALPOSTING');"
+ " if (ProvisionalCheck = false){"
+ " if (confirm('This will create all of the depreciation transactions for the select period - are you sure you want to continue?')) {\n"
+ " }else{\n"
+ " //reset the check box;\n"
+ " document.getElementById('PROVISIONALPOSTING').checked = true;\n"
+ " }\n"
+ " }\n"
+ "}\n"
+ "</script>\n");
out.println("</BODY></HTML>");
}
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doPost(request, response);
}
private void List_Criteria(PrintWriter pwOut,
String sDBID,
String sUser,
HttpServletRequest req) throws Exception{
pwOut.println("<TABLE BORDER=12 CELLSPACING=2>");
ArrayList<String> sYearValues = new ArrayList<String>();
ArrayList<String> sYearDescriptions = new ArrayList<String>();
ArrayList<String> sPeriodValues = new ArrayList<String>();
ArrayList<String> sPeriodDescriptions = new ArrayList<String>();
Calendar c = Calendar.getInstance();
c.setTimeInMillis(System.currentTimeMillis());
pwOut.println("\n" + "<INPUT TYPE=HIDDEN NAME='" + SHOWALLLOCATIONS_PARAMETER + "' VALUE = 'N' >" + "\n");
try{
//Fiscal year:
sYearValues.clear();
sYearDescriptions.clear();
//First, add a blank to make sure the user selects one:
sYearValues.add("");
sYearDescriptions.add("--- Select a fiscal year ---");
for (int i=0;i<100;i++){
sYearValues.add(String.valueOf(1970 + i));
sYearDescriptions.add(String.valueOf(1970 + i));
}
//Fiscal period:
sPeriodValues.clear();
sPeriodDescriptions.clear();
//First, add a blank to make sure the user selects one:
sPeriodValues.add("");
sPeriodDescriptions.add("-- Select a fiscal period --");
for (int i=1;i<=13;i++){
sPeriodValues.add(String.valueOf(i));
sPeriodDescriptions.add(String.valueOf(i));
}
pwOut.println(clsCreateHTMLTableFormFields.Create_Edit_Form_List_Row(
"STARTFISCALYEAR",
sYearValues,
String.valueOf(c.get(Calendar.YEAR)),
sYearDescriptions,
"Transactions starting with fiscal year:",
" "
)
);
pwOut.println(clsCreateHTMLTableFormFields.Create_Edit_Form_List_Row(
"STARTFISCALPERIOD",
sPeriodValues,
String.valueOf(c.get(Calendar.MONTH) + 1),
sPeriodDescriptions,
"Transactions starting with fiscal period:",
" "
)
);
pwOut.println(clsCreateHTMLTableFormFields.Create_Edit_Form_List_Row(
"ENDFISCALYEAR",
sYearValues,
String.valueOf(c.get(Calendar.YEAR)),
sYearDescriptions,
"Transactions ending with fiscal year:",
" "
)
);
pwOut.println(clsCreateHTMLTableFormFields.Create_Edit_Form_List_Row(
"ENDFISCALPERIOD",
sPeriodValues,
String.valueOf(c.get(Calendar.MONTH) + 1),
sPeriodDescriptions,
"Transactions ending with fiscal period:",
" "
)
);
}catch (Exception e){
throw new Exception ("Error: " + e.getMessage());
}
//checkboxes
//Print provisional posting?
pwOut.println(
"<TR>"
+ "<TD ALIGN=RIGHT>Print provisional transactions </TD>"
+ "<TD ALIGN=LEFT>"
+ "<INPUT TYPE=CHECKBOX NAME=\"PRINTPROVISIONALTRANSACTION\""
+ clsServletUtilities.CHECKBOX_UNCHECKED_STRING
+ " STYLE=\"height: 0.25in\""
+ " onClick=\"confirmation()\"></TD>"
+ "<TD ALIGN=LEFT> </TD>"
+ "</TR>"
);
//Print adjustment transactions?
pwOut.println(
"<TR>"
+ "<TD ALIGN=RIGHT>Print adjustment transactions </TD>"
+ "<TD ALIGN=LEFT>"
+ "<INPUT TYPE=CHECKBOX NAME=\"PRINTADJUSTMENTTRANSACTION\""
+ clsServletUtilities.CHECKBOX_UNCHECKED_STRING
+ " STYLE=\"height: 0.25in\"></TD>"
+ "<TD ALIGN=LEFT> </TD>"
+ "</TR>"
);
//Print actual transactions?
pwOut.println(
"<TR>"
+ "<TD ALIGN=RIGHT>Print actual transactions </TD>"
+ "<TD ALIGN=LEFT>"
+ "<INPUT TYPE=CHECKBOX NAME=\"PRINTACTUALTRANSACTION\""
+ clsServletUtilities.CHECKBOX_UNCHECKED_STRING
+ " STYLE=\"height: 0.25in\"></TD>"
+ "<TD ALIGN=LEFT> </TD>"
+ "</TR>"
);
//Include details?
pwOut.println(
"<TR>"
+ "<TD ALIGN=RIGHT>Show details </TD>"
+ "<TD ALIGN=LEFT>"
+ "<INPUT TYPE=CHECKBOX NAME=\"SHOWDETAILS\""
+ clsServletUtilities.CHECKBOX_UNCHECKED_STRING
+ " STYLE=\"height: 0.25in\""
+ "></TD>"
+ "<TD ALIGN=LEFT> </TD>"
+ "</TR>"
);
//Group by asset class OR by GL account:
pwOut.println(
"<TR>"
+ "<TD ALIGN=RIGHT><B>Group by:</B> </TD>"
+ "<TD ALIGN=LEFT>"
+ "<LABEL>Asset Class <INPUT TYPE=RADIO NAME= '" + GROUPBY_PARAMETER + "' VALUE = '" + GROUPBY_VALUE_CLASS + "' CHECKED ></LABEL>"
+ " <LABEL>GL Account <INPUT TYPE=RADIO NAME= '" + GROUPBY_PARAMETER + "' VALUE = '" + GROUPBY_VALUE_GL + "' ></LABEL>"
+ "</TD>"
+ "<TD ALIGN=LEFT> </TD>"
+ "</TR>"
);
//Locations:
try{
//select location
String sSQL = "SELECT"
+ " " + SMTablelocations.sLocation
+ ", " + SMTablelocations.sLocationDescription
+ " FROM " + SMTablelocations.TableName
//+ " WHERE ("
// + "(" + SMTablelocations.ishowintruckschedule + " = 1)"
//+ ")"
+ " ORDER BY " + SMTablelocations.sLocation
;
ResultSet rsLocations = clsDatabaseFunctions.openResultSet(
sSQL,
getServletContext(),
sDBID,
"MySQL",
"smfal.FATransactionListSelect");
pwOut.println("\n <TR>\n"
+ " <TD ALIGN=RIGHT VALIGN=TOP><H4>ONLY show assets assigned to these locations: </H4></TD>\n"
+ " <TD>\n");
String sChecked = "";
while(rsLocations.next()){
String sLocation = rsLocations.getString(SMTablelocations.TableName + "."
+ SMTablelocations.sLocation).trim();
pwOut.println(
"<LABEL NAME=\"" + CHECKBOX_LABEL + sLocation + "\"" + ">"
+ "<INPUT TYPE=CHECKBOX NAME=\"" + LOCATION_PARAMETER
+ sLocation + "\""
);
if (
(req.getParameter(LOCATION_PARAMETER + sLocation) != null)
){
sChecked = clsServletUtilities.CHECKBOX_CHECKED_STRING;
}else{
sChecked = "";
}
pwOut.println(" " + sChecked + " "
+ " width=0.25>"
+ sLocation + " - "
+ rsLocations.getString(SMTablelocations.TableName + "." + SMTablelocations.sLocationDescription) + "<BR>" + "\n");
pwOut.println("</LABEL>" + "\n");
}
rsLocations.close();
pwOut.println(" <TD> </TD>\n");
pwOut.println("</TR>");
} catch(Exception e){
pwOut.println("<BR><FONT COLOR=RED><B>Error [1549052143] reading locations - " + e.getMessage() + ".</B></FONT><BR>");
}
pwOut.println("</TABLE>");
//pwOut.println("<BR>");
pwOut.println("<P><INPUT TYPE=SUBMIT NAME='SubmitPrint' VALUE='Print' STYLE='height: 0.24in'></P>");
}
}
| true |
b542f111fa1ad4d262fe0510c143dddfe36a6468 | Java | 1803023737/pyg_parent | /clouddemo/bootdemo512/src/main/java/com/importdemo2/MyImportBeanDefinitionRegistrar.java | UTF-8 | 865 | 2.21875 | 2 | [] | no_license | package com.importdemo2;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//่ชๅทฑๆๅจๆณจๅ
ฅๅฏน่ฑก
BeanDefinitionBuilder builder=BeanDefinitionBuilder.rootBeanDefinition(Student.class);
BeanDefinition beanDefinition=builder.getBeanDefinition();
registry.registerBeanDefinition("student", beanDefinition);
}
}
| true |
cee59beafaf84ec371d02dfe017460c1a04a8f3e | Java | JesusPatate/HADL | /fr.univnantes.alma.hadl.m2/src/fr/univnantes/alma/hadl/m2/component/AtomicComponent.java | UTF-8 | 357 | 1.976563 | 2 | [] | no_license | package fr.univnantes.alma.hadl.m2.component;
import fr.univnantes.alma.hadl.m2.configuration.ComponentConfiguration;
public abstract class AtomicComponent extends Component {
public AtomicComponent(final String label, ComponentConfiguration composite) {
super(label, composite);
}
public AtomicComponent(final String label) {
super(label);
}
}
| true |
946920b9e7d04d30842fda624016931737492518 | Java | histnat/mithraFamilly | /portail famille/workspaceMaquette/toolbox/src/test/java/net/mithra/toolbox/io/ReplaceFilterInputStreamTest.java | UTF-8 | 7,900 | 2.703125 | 3 | [] | no_license | package net.mithra.toolbox.io;
import static org.junit.Assert.assertArrayEquals;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.junit.Ignore;
import org.junit.Test;
/**
* @author Denis Zhdanov
* @since 08/31/2009
*/
@SuppressWarnings({"IOResourceOpenedButNotSafelyClosed", "SuppressionAnnotation"})
public class ReplaceFilterInputStreamTest {
@Test(expected = IllegalArgumentException.class)
public void nullReplacements() {
new ReplaceFilterInputStream(new ByteArrayInputStream(new byte[]{1, 2}), null);
}
@Test(expected = IllegalArgumentException.class)
public void nullReplacementKey() {
new ReplaceFilterInputStream(
new ByteArrayInputStream(new byte[]{1, 2}),
Collections.<byte[], byte[]>singletonMap(null, new byte[]{3, 4})
);
}
@Test(expected = IllegalArgumentException.class)
public void nullReplacementValue() {
new ReplaceFilterInputStream(
new ByteArrayInputStream(new byte[]{1, 2}),
Collections.<byte[], byte[]>singletonMap(new byte[]{3, 4}, null)
);
}
@Test
public void emptyReplacements() throws IOException {
byte[] input = {1, 3, 4, 6};
doTest(input, input, new HashMap<byte[], byte[]>());
}
@Test
public void emptyReplacementKey() throws IOException {
byte[] input = {1, 2, 3, 4};
doTest(input, input, Collections.singletonMap(new byte[0], new byte[]{5, 6}));
}
@Test
public void fromAndToOfSameSize() throws IOException {
String input = "ddasfddtredd";
String from = "dd";
String to = "pp";
doTest(input, from, to);
}
@Test
public void multipleFromOfSameSize() throws IOException {
String input = "aabcc";
Map<String, String> replacements = new HashMap<String, String>();
replacements.put("aa", "zz");
replacements.put("cc", "yy");
doTest(input, replacements);
}
@Test
public void fromLongerThanTo() throws IOException {
String input = "wpoeqwportwpo";
String from = "wpo";
String to = "a";
doTest(input, from, to);
}
@Test
public void toLongerThanFrom() throws IOException {
String input = "weqwrtw";
String from = "w";
String to = "asd";
doTest(input, from, to);
}
//TODO : problem come from read function.
//@Test
public void toClashesFrom() throws IOException {
String input = "abc";
String from = "a";
String to = "aaa";
doTest(input, from, to);
input = "aaa";
doTest(input, from, to);
}
@Test
public void removeReplace() throws IOException {
String input = "cabcabcac";
String from = "ca";
String to = "";
doTest(input, from, to);
}
@Test
public void bufferSizeLessThanReplacementSize() throws IOException {
byte[] input = {1, 2, 3, 4, 5};
ReplaceFilterInputStream in = new ReplaceFilterInputStream(
new ByteArrayInputStream(input),
Collections.singletonMap(new byte[]{1, 2, 3}, new byte[]{6})
);
byte[] buffer = new byte[2];
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
int read;
while ((read = in.read(buffer)) >= 0) {
bOut.write(buffer, 0, read);
}
assertArrayEquals(new byte[]{6, 4, 5}, bOut.toByteArray());
}
@Test
public void bufferOverflow() throws IOException {
String input = "abcde";
Map<String, String> replacements = new HashMap<String, String>();
replacements.put("a", "111111111");
replacements.put("b", "ABCDEFGHI");
replacements.put("c", "333333333");
replacements.put("d", "444444444");
replacements.put("e", "555555555");
doTest(input, replacements);
input = "aaaaa";
String from = "a";
String to = "bbbbbbbbb";
doTest(input, from, to);
input = "aaaaaaa";
to = "bb";
doTest(input, from, to);
}
@Test
public void slowStream() throws IOException {
final byte[] from = {1, 1, 1, 1, 1};
final byte[] to = {2};
InputStream in = new InputStream() {
private int i;
@Override
public int read() throws IOException {
return i < from.length ? from[i++] : -1;
}
@Override
public int read(byte b[], int off, int len) throws IOException {
int read = read();
if (read < 0) {
return -1;
}
b[off] = (byte) read;
return 1;
}
};
ReplaceFilterInputStream stream = new ReplaceFilterInputStream(in, Collections.singletonMap(from, to));
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
int read;
while ((read = stream.read()) >= 0) {
bOut.write(read);
}
in.close();
bOut.close();
assertArrayEquals(to, bOut.toByteArray());
}
private void doTest(byte[] input, byte[] expected, Map<byte[], byte[]> replacements) throws IOException {
ReplaceFilterInputStream in = new ReplaceFilterInputStream(new ByteArrayInputStream(input), replacements);
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
int read;
while ((read = in.read()) >= 0) {
bOut.write(read);
}
in.close();
bOut.close();
assertArrayEquals(expected, bOut.toByteArray());
}
private void doTest(String input, String from, String to) throws IOException {
doTest(input, Collections.singletonMap(from, to));
}
private void doTest(String input, Map<String, String> replacements) throws IOException {
String expected = input;
for (Map.Entry<String, String> entry : replacements.entrySet()) {
expected = expected.replace(entry.getKey(), entry.getValue());
}
byte[] rawExpected = expected.getBytes();
testSingleByteRead(rawExpected, input, replacements);
testBufferedRead(rawExpected, input, replacements);
}
private void testSingleByteRead(byte[] expected, String input, Map<String, String> replacements) throws IOException {
ReplaceFilterInputStream in = getInputStream(input, replacements);
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
int read;
while ((read = in.read()) >= 0) {
bOut.write(read);
}
bOut.close();
assertArrayEquals(expected, bOut.toByteArray());
}
private void testBufferedRead(byte[] expected, String input, Map<String, String> replacements) throws IOException {
ReplaceFilterInputStream in = getInputStream(input, replacements);
ByteArrayOutputStream bOut = new ByteArrayOutputStream();
byte[] buffer = new byte[3];
int read;
while ((read = in.read(buffer)) >= 0) {
bOut.write(buffer, 0, read);
}
bOut.close();
assertArrayEquals(expected, bOut.toByteArray());
}
private ReplaceFilterInputStream getInputStream(String input, Map<String, String> replacements) {
ByteArrayInputStream bIn = new ByteArrayInputStream(input.getBytes());
Map<byte[], byte[]> rawReplacements = new HashMap<byte[], byte[]>();
for (Map.Entry<String, String> entry : replacements.entrySet()) {
rawReplacements.put(entry.getKey().getBytes(), entry.getValue().getBytes());
}
return new ReplaceFilterInputStream(bIn, rawReplacements);
}
}
| true |
d9a2801fe3537760a6f1674856fc12446de36296 | Java | ctt-gob-es/jmulticard | /jmulticard/src/main/java/es/gob/jmulticard/card/dnie/ceressc/CeresSc.java | UTF-8 | 15,612 | 1.59375 | 2 | [] | no_license | package es.gob.jmulticard.card.dnie.ceressc;
import java.io.IOException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.security.interfaces.RSAPublicKey;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.PasswordCallback;
import es.gob.jmulticard.CryptoHelper;
import es.gob.jmulticard.HexUtils;
import es.gob.jmulticard.apdu.CommandApdu;
import es.gob.jmulticard.apdu.ResponseApdu;
import es.gob.jmulticard.apdu.iso7816eight.PsoSignHashApduCommand;
import es.gob.jmulticard.apdu.iso7816four.MseSetComputationApduCommand;
import es.gob.jmulticard.asn1.Asn1Exception;
import es.gob.jmulticard.asn1.TlvException;
import es.gob.jmulticard.asn1.custom.fnmt.ceressc.CeresScPrKdf;
import es.gob.jmulticard.asn1.der.pkcs1.DigestInfo;
import es.gob.jmulticard.asn1.der.pkcs15.Cdf;
import es.gob.jmulticard.asn1.der.pkcs15.Pkcs15Cdf;
import es.gob.jmulticard.asn1.der.pkcs15.PrKdf;
import es.gob.jmulticard.card.Atr;
import es.gob.jmulticard.card.CardMessages;
import es.gob.jmulticard.card.CompressionUtils;
import es.gob.jmulticard.card.CryptoCardException;
import es.gob.jmulticard.card.InvalidCardException;
import es.gob.jmulticard.card.Location;
import es.gob.jmulticard.card.PinException;
import es.gob.jmulticard.card.PrivateKeyReference;
import es.gob.jmulticard.card.cwa14890.Cwa14890PrivateConstants;
import es.gob.jmulticard.card.cwa14890.Cwa14890PublicConstants;
import es.gob.jmulticard.card.dnie.Dnie;
import es.gob.jmulticard.card.dnie.DnieCardException;
import es.gob.jmulticard.card.dnie.DniePrivateKeyReference;
import es.gob.jmulticard.card.iso7816four.Iso7816FourCardException;
import es.gob.jmulticard.connection.ApduConnection;
import es.gob.jmulticard.connection.ApduConnectionException;
import es.gob.jmulticard.connection.LostChannelException;
import es.gob.jmulticard.connection.cwa14890.Cwa14890Connection;
import es.gob.jmulticard.connection.cwa14890.Cwa14890OneV2Connection;
/** Tarjeta FNMT CERES con canal seguro.
* @author Tomás García-Merás. */
public final class CeresSc extends Dnie {
private static final byte[] ATR_MASK_TC = {
(byte) 0xff, (byte) 0xff, (byte) 0x00, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
(byte) 0xff, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0xff, (byte) 0xff, (byte) 0xff
};
/** ATR de las tarjetas FNMT CERES 4.30 y superior. */
public static final Atr ATR_TC = new Atr(new byte[] {
(byte) 0x3B, (byte) 0x7F, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x6A, (byte) 0x46, (byte) 0x4E, (byte) 0x4d,
(byte) 0x54, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x03, (byte) 0x90, (byte) 0x00
}, ATR_MASK_TC);
private static String cardVersion = null;
/** Certificados de la tarjeta indexados por su alias. */
private transient Map<String, X509Certificate> certs;
/** Alias de los certificados de la tarjeta indexados por el identificador
* interno del certificado (pasado de <code>byte[]</code> a <code>String</code>). */
private transient Map<String, String> aliasByCertAndKeyId;
/** Referencias a las claves privadas de la tarjeta indexadas por el alias
* de su certificado asociado. */
private transient Map<String, DniePrivateKeyReference> keyReferences;
/** Construye una tarjeta FNMT CERES con canal seguro.
* @param conn Conexión con la tarjeta.
* @param pwc <i>PasswordCallback</i> para obtener el PIN de la tarjeta.
* @param cryptoHlpr Funcionalidades criptográficas de utilidad que pueden
* variar entre máquinas virtuales.
* @param ch Gestor de <i>callbacks</i> para la solicitud de datos al usuario.
* @throws ApduConnectionException Si la conexión con la tarjeta se
* proporciona cerrada y no es posible abrirla.
* @throws InvalidCardException Si la tarjeta no es una CERES 4.30 o superior. */
public CeresSc(final ApduConnection conn,
final PasswordCallback pwc,
final CryptoHelper cryptoHlpr,
final CallbackHandler ch) throws ApduConnectionException,
InvalidCardException {
this(conn, pwc, cryptoHlpr, ch, true);
}
/** Construye una tarjeta FNMT CERES con canal seguro.
* @param conn Conexión con la tarjeta.
* @param pwc <i>PasswordCallback</i> para obtener el PIN de la tarjeta.
* @param cryptoHlpr Funcionalidades criptográficas de utilidad que pueden
* variar entre máquinas virtuales.
* @param ch Gestor de <i>callbacks</i> para la solicitud de datos al usuario.
* @param loadCertsAndKeys Si se indica <code>true</code>, se cargan las referencias a
* las claves privadas y a los certificados, mientras que si se
* indica <code>false</code>, no se cargan, permitiendo la
* instanciación de una tarjeta sin capacidades de firma o
* autenticación con certificados.
* @throws ApduConnectionException Si la conexión con la tarjeta se
* proporciona cerrada y no es posible abrirla.
* @throws InvalidCardException Si la tarjeta no es una CERES 4.30 o superior. */
public CeresSc(final ApduConnection conn,
final PasswordCallback pwc,
final CryptoHelper cryptoHlpr,
final CallbackHandler ch,
final boolean loadCertsAndKeys) throws ApduConnectionException,
InvalidCardException {
super(conn, pwc, cryptoHlpr, ch, loadCertsAndKeys);
checkAtr(conn.reset());
}
@Override
public X509Certificate getCertificate(final String alias) {
return certs.get(alias);
}
@Override
protected byte[] signOperation(final byte[] data,
final String algorithm,
final PrivateKeyReference privateKeyReference) throws CryptoCardException,
PinException {
openSecureChannelIfNotAlreadyOpened();
ResponseApdu res;
try {
CommandApdu apdu = new MseSetComputationApduCommand(
(byte) 0x00, ((DniePrivateKeyReference) privateKeyReference).getKeyPath().getLastFilePath(),
null
);
res = getConnection().transmit(apdu);
if (!res.isOk()) {
throw new DnieCardException(
"Error en el establecimiento de las clave de firma con respuesta: " + //$NON-NLS-1$
res.getStatusWord(),
res.getStatusWord()
);
}
final byte[] digestInfo;
try {
digestInfo = DigestInfo.encode(algorithm, data, cryptoHelper);
}
catch (final IOException e) {
throw new DnieCardException("Error en el calculo del hash para firmar", e); //$NON-NLS-1$
}
apdu = new PsoSignHashApduCommand((byte) 0x00, digestInfo);
res = getConnection().transmit(apdu);
if (!res.isOk()) {
throw new DnieCardException(
"Error durante la operacion de firma (tarjeta CERES) con respuesta: " + //$NON-NLS-1$
res.getStatusWord(),
res.getStatusWord()
);
}
}
catch(final LostChannelException e) {
try {
getConnection().close();
if (getConnection() instanceof Cwa14890Connection) {
setConnection(((Cwa14890Connection) getConnection()).getSubConnection());
}
}
catch (final ApduConnectionException ex) {
throw new DnieCardException("No se pudo recuperar el canal seguro para firmar (" + e + ")", ex); //$NON-NLS-1$ //$NON-NLS-2$
}
return signOperation(data, algorithm, privateKeyReference);
}
catch (final ApduConnectionException e) {
throw new DnieCardException("Error en la transmision de comandos a la tarjeta", e); //$NON-NLS-1$
}
return res.getData();
}
@Override
protected Cwa14890PublicConstants getCwa14890PublicConstants() {
return new CeresScCwa14890Constants();
}
@Override
protected Cwa14890PrivateConstants getCwa14890PrivateConstants() {
return new CeresScCwa14890Constants();
}
/** Carga el certificado de la CA intermedia y las localizaciones del resto de los certificados.
* @throws ApduConnectionException Si hay problemas en la precarga. */
@Override
protected void loadCertificatesPaths() throws ApduConnectionException {
try {
preload();
}
catch (final Exception e) {
throw new ApduConnectionException(
"Error cargando las estructuras iniciales de la tarjeta", e //$NON-NLS-1$
);
}
}
/** Carga la información pública con la referencia a las claves de firma. */
@Override
protected void loadKeyReferences() {
// Vacio, lo hacemos todo en la precarga de certificados
}
@Override
public String[] getAliases() {
return certs.keySet().toArray(new String[0]);
}
@Override
public PrivateKeyReference getPrivateKey(final String alias) {
return keyReferences.get(alias);
}
private void preload() throws ApduConnectionException,
Iso7816FourCardException,
IOException,
CertificateException,
Asn1Exception,
TlvException {
// Nos vamos al raiz antes de nada
selectMasterFile();
// Leemos el CDF
final byte[] cdfBytes = selectFileByLocationAndRead(CDF_LOCATION);
// Cargamos el CDF
final Pkcs15Cdf cdf = new Cdf();
cdf.setDerValue(cdfBytes);
certs = new LinkedHashMap<>(cdf.getCertificateCount());
aliasByCertAndKeyId = new LinkedHashMap<>(cdf.getCertificateCount());
for (int i = 0; i < cdf.getCertificateCount(); i++) {
final Location l = new Location(
cdf.getCertificatePath(i).replace("\\", "").trim() //$NON-NLS-1$ //$NON-NLS-2$
);
final X509Certificate cert = CompressionUtils.getCertificateFromCompressedOrNotData(
selectFileByLocationAndRead(l),
cryptoHelper
);
final String alias = i + " " + cert.getSerialNumber(); //$NON-NLS-1$
aliasByCertAndKeyId.put(HexUtils.hexify(cdf.getCertificateId(i), false), alias);
certs.put(alias, cert);
}
// Leemos el PrKDF
final byte[] prkdfValue = selectFileByLocationAndRead(PRKDF_LOCATION);
// Establecemos el valor del PrKDF
PrKdf prkdf;
try {
prkdf = new PrKdf();
prkdf.setDerValue(prkdfValue);
}
catch(final Exception e) {
LOGGER.warning(
"Detectado posible PrKDF con CommonPrivateKeyAttributes vacio, se prueba con estructura alternativa: " + e //$NON-NLS-1$
);
prkdf = new CeresScPrKdf();
prkdf.setDerValue(prkdfValue);
}
keyReferences = new LinkedHashMap<>();
for (int i = 0; i < prkdf.getKeyCount(); i++) {
final String alias = aliasByCertAndKeyId.get(HexUtils.hexify(prkdf.getKeyId(i), false));
if (alias != null) {
keyReferences.put(
alias,
new DniePrivateKeyReference(
this,
prkdf.getKeyIdentifier(i),
new Location(prkdf.getKeyPath(i)),
prkdf.getKeyName(i),
prkdf.getKeyReference(i),
((RSAPublicKey)certs.get(alias).getPublicKey()).getModulus().bitLength()
)
);
}
}
// Sincronizamos claves y certificados
hideCertsWithoutKey();
}
/** Oculta los certificados que no tienen una clave privada asociada. */
private void hideCertsWithoutKey() {
final String[] aliases = getAliases();
for (final String alias : aliases) {
if (keyReferences.get(alias) == null) {
certs.remove(alias);
}
}
}
/** Establece y abre el canal seguro CWA-14890 si no lo estaba ya hecho.
* @throws CryptoCardException Si hay problemas en el proceso.
* @throws PinException Si el PIN usado para la apertura de canal no es válido o no se ha proporcionado
* un PIN para validar. */
@Override
public void openSecureChannelIfNotAlreadyOpened() throws CryptoCardException, PinException {
if (isSecurityChannelOpen()) {
return;
}
if (DEBUG) {
LOGGER.info("Conexion actual: " + getConnection()); //$NON-NLS-1$
LOGGER.info("Conexion subyacente: " + rawConnection); //$NON-NLS-1$
}
// Si la conexion esta cerrada, la reestablecemos
if (!getConnection().isOpen()) {
try {
setConnection(rawConnection);
}
catch (final ApduConnectionException e) {
throw new CryptoCardException(
"Error en el establecimiento del canal inicial", e //$NON-NLS-1$
);
}
}
// Aunque el canal seguro estuviese cerrado, podria si estar enganchado
if (!(getConnection() instanceof Cwa14890Connection)) {
final ApduConnection secureConnection = new Cwa14890OneV2Connection(
this,
getConnection(),
cryptoHelper,
getCwa14890PublicConstants(),
getCwa14890PrivateConstants()
);
try {
selectMasterFile();
}
catch (final Exception e) {
LOGGER.warning(
"Error seleccionando el MF tras el establecimiento del canal seguro de PIN: " + e //$NON-NLS-1$
);
}
try {
setConnection(secureConnection);
}
catch (final ApduConnectionException e) {
throw new CryptoCardException("Error en el establecimiento del canal seguro", e); //$NON-NLS-1$
}
}
try {
verifyPin(getInternalPasswordCallback());
}
catch (final ApduConnectionException e) {
throw new CryptoCardException("Error en la apertura del canal seguro", e); //$NON-NLS-1$
}
}
@Override
protected boolean needAuthorizationToSign() {
return false;
}
@Override
protected String getPinMessage(final int retriesLeft) {
return CardMessages.getString("Gen.0", Integer.toString(retriesLeft)); //$NON-NLS-1$
}
private static void checkAtr(final byte[] atrBytes) throws InvalidCardException {
final Atr tmpAtr = new Atr(atrBytes, ATR_MASK_TC);
if (ATR_TC.equals(tmpAtr) && atrBytes[15] >= (byte) 0x04 && atrBytes[16] >= (byte) 0x30) {
cardVersion = HexUtils.hexify(new byte[] { atrBytes[15] }, false) + "." + HexUtils.hexify(new byte[] { atrBytes[16] }, false); //$NON-NLS-1$
LOGGER.info(
"Encontrada TC CERES en version " + cardVersion //$NON-NLS-1$
);
return;
}
throw new InvalidCardException("CERES", ATR_TC, atrBytes); //$NON-NLS-1$
}
@Override
public String toString() {
return "Tarjeta FNMT CERES" + (cardVersion != null ? " version " + cardVersion : ""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
}
}
| true |
b9b7348321524ea01912d44eb74ecaf22409945b | Java | ebizon/mofluid-community-android | /moFluid/src/main/java/com/ebizon/fluid/model/ShoppingCart.java | UTF-8 | 5,156 | 2.28125 | 2 | [] | no_license | package com.ebizon.fluid.model;
import android.util.Log;
import com.mofluid.magento2.database.MyDataBaseAdapter;
import com.mofluid.magento2.fragment.BaseFragment;
import com.mofluid.magento2.fragment.MyCartFragment;
import com.mofluid.magento2.fragment.SimpleProductFragment2;
import com.mofluid.magento2.service.AppController;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
/**
* Created by manish on 08/03/16.
*/
public class ShoppingCart {
private static ShoppingCart ourInstance = new ShoppingCart();
private MyDataBaseAdapter dataBaseAdapter;
public static ShoppingCart getInstance() {
return ourInstance;
}
private HashMap<String, ShoppingCartItem> cart = new HashMap<>();
private String coupon;
private ShoppingCart() {
this.dataBaseAdapter=new MyDataBaseAdapter(AppController.getContext());
}
public void setCartFromServer()
{
/* CartSync.getInstance().UpdateAppCart(UserManager.getInstance().getUser().getId(), new IResponseListener() {
@Override
public void onResponse(boolean result, ArrayList<ShoppingCartItem> data) {
if(result==true)
{
for (int i = 0; i < data.size(); i++) {
ShoppingCartItem item = data.get(i);
ShoppingCart.getInstance().addItemFromServer(item);
}
}
else {
}
}
});*/
}
public void addItem(ShoppingCartItem item){
this.cart.put(item.getShoppingItem().getId(), item);
this.dataBaseAdapter.insertItemtoCart(item);
}
public void addItem(ShoppingCartItem item, BaseFragment simpleProductFragment2){
this.cart.put(item.getShoppingItem().getParentID(), item);
this.dataBaseAdapter.insertItemtoCart(item);
UserProfileItem currentuser = UserManager.getInstance().getUser();
/* if(currentuser!=null && currentuser.getLogin_status()!="0") {
String customerid = currentuser.getId();
CartSync.getInstance().updateServerCartAdd(customerid, item.getShoppingItem().getId(),item.getCount(),simpleProductFragment2); //CARTSYNC ADD
}
else {*/
Log.d("Piyush", "Guest user, not calling cart sync add ");
if (simpleProductFragment2.getClass().getSimpleName().equals("SimpleProductFragment2")) {
SimpleProductFragment2 f = (SimpleProductFragment2) simpleProductFragment2;
f.callF();
Log.d("PiyushCarySync", "called fragmet name");
}
// }
}
public void deleteItem(ShoppingCartItem item, MyCartFragment myCartFragment){
this.cart.remove(item.getShoppingItem().getId());
int res = this.dataBaseAdapter.deleteSingleItemFromCart(item);
if(res>0)
{
//success
}
/* UserProfileItem currentuser = UserManager.getInstance().getUser();
if(currentuser!=null && currentuser.getLogin_status()!="0") {
String customerid = currentuser.getId();
CartSync.getInstance().updateServerCartDelete(customerid,item.getShoppingItem().getId()); //CARTSYNC DELETE
}
else
Log.d("Piyush", "Guest user, not calling cart sync delete ");
*/
if(this.cart.isEmpty()){
this.coupon = null;
}
}
public int getCount(String id){
int count = 0;
if(this.cart.containsKey(id)){
count = this.cart.get(id).getCount();
}
return count;
}
public int getCount(ShoppingItem item){
return this.getCount(item.getId());
}
public int getNumDifferentItems(){
return this.cart.size();
}
public double getSubTotal(ShoppingItem item){
return getCount(item) * item.getFinalPrice();
}
public double getSubTotal(){
double subTotal = 0.0;
Set<String> itemIds = this.cart.keySet();
for(String id : itemIds){
ShoppingItem item = this.cart.get(id).getShoppingItem();
subTotal += this.getSubTotal(item);
}
return subTotal;
}
public Collection<ShoppingCartItem> getCartItems(){
return this.cart.values();
}
public void clearCart(){
this.cart.clear();
}
public void addItemFromServer(ShoppingCartItem item)
{
this.cart.put(item.getShoppingItem().getId(), item);
}
public void addAllCartFromDB(HashMap<String,ShoppingCartItem> cartList)
{
this.cart.putAll(cartList);
}
public String getCartItemsId()
{
String res = "";
Iterator itr = this.cart.keySet().iterator();
while (itr.hasNext()) {
String key = (String) itr.next();
if(itr.hasNext())
res+=key+",";
else
res+=key+"";
}
Log.d("HashMap",res);
return res;
}
public ShoppingCartItem getSingleCartItemfromID(String key)
{
return this.cart.get(key);
}
}
| true |
b69b5b9caf46f8906dbdf0362e0355f1b0763938 | Java | peacememories/reactivision | /src/main/java/agents/Agent.java | UTF-8 | 4,367 | 2.96875 | 3 | [] | no_license | package agents; /**
* Created by moru on 5/26/2015.
*/
import facilities.Facility;
import facilities.FacilityType;
import processing.core.PVector;
import stores.FacilitiesStore;
import util.Conf;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Agent {
private Random random;
private float secondsToGoalChange = 0.0f;
// controls whether the agent is in random mode (just wandering) or moving towards a goal
private boolean idle = true;
private float speed = 0.0f;
private PVector position, goal;
private float happiness = 0.0f;
// likes each type of facility with a random score between -1 and 1
public Map<FacilityType, Float> preferences;
public Agent(long seed) {
random = new Random(seed);
PVector pos = randomGoal();
// crosses table in 5 to 9 seconds if moving perfectly along axis
float v = Math.min(Conf.SCREEN_HEIGHT, Conf.SCREEN_WIDTH) /
(5 + 4 * random.nextFloat());
//System.out.println("With speed: " + v);
this.position = pos;
setSpeed(v);
preferences = new HashMap<>();
float excitation = random.nextFloat();
//System.out.println(excitation);
preferences.put(FacilityType.SPORT, -excitation * 0.01f);
preferences.put(FacilityType.CLUB, excitation * 0.01f);
}
public void update(float deltaSeconds) {
secondsToGoalChange -= deltaSeconds;
if(secondsToGoalChange < 0 && idle) {
// run 3 to 11 seconds in the same direction for the next goal
secondsToGoalChange = 3 + random.nextFloat() * 8;
setGoal(randomGoal());
}
// move towards goal -----
PVector path = goal.get();
path.sub(position);
PVector direction = path.get();
direction.normalize();
PVector move = direction.get();
move.mult(deltaSeconds * speed);
// make the move
if(path.mag() < move.mag()) {
// we've reached the goal
this.position = goal.get();
idle = true; //change into idle mode
setGoal(randomGoal());
} else {
// move closer
this.position.add(move);
}
// check if close to any facilities
/*
* TODO proper trajectory collision detection, e.g.:
* if (exists(pos) where (facilityPos - pos).mag() < (radius + facilityRadius)) {
*/
for(Facility f : FacilitiesStore.getStore().getFacilities()) {
PVector toFacility = f.position.get();
toFacility.sub(position);
if(toFacility.mag() < f.radius) {
// in a facilities zone of influence
//hasBeenInFacility = true;
float deltaHappiness = preferences.get(f.type).floatValue();
this.happiness += deltaHappiness;
this.happiness = Math.min(1.0f, Math.max(-1.0f, this.happiness));
/*
System.out.println("In facility of type " + f.type + " which satisfies by "
+ deltaHappiness + " (total: " + happiness + ")");
System.out.println("Preferences: " + preferences);
*/
//TODO less strong (bend current path by strength of delta
if (deltaHappiness >= 0) {
// TODO if agent likes the facility: set goal to center
//setGoal(f.position);
} else {
// TODO if negative: set goal away from center
}
//TODO if it hasn't been in a center, lessen excitation (change towards 0)
}
}
}
private PVector randomGoal() {
int x = random.nextInt(Conf.SCREEN_WIDTH);
int y = random.nextInt(Conf.SCREEN_HEIGHT);
return new PVector(x, y);
}
public Agent setGoal(PVector goal) {
this.idle = false;
this.goal = goal;
return this;
}
/**
* @param speed in units per second
* @return
*/
public Agent setSpeed(float speed) {
this.speed = speed;
return this;
}
public PVector getPosition(){
return position.get();
}
public float getHappiness() {
return happiness;
}
}
| true |
06f67630be0e1580f46d49a1ec16612847ce876f | Java | llaith/atlas-dropwizard-microservice-bootstrap | /atlas-helloworld/atlas-helloworld-microservice/src/test/java/tkt/atlas/helloworld/service/HelloWorldAsyncServiceTest.java | UTF-8 | 1,979 | 2.5625 | 3 | [
"Apache-2.0"
] | permissive | package tkt.atlas.helloworld.service;
import org.junit.Before;
import org.junit.Test;
import tkt.atlas.helloworld.api.HelloWorldAsyncService;
import tkt.atlas.helloworld.api.domain.Person;
import java.util.Date;
import static org.junit.Assert.*;
import static tkt.util.ObservableUtil.firstFrom;
import static tkt.util.ObservableUtil.testSubscriptionOn;
/**
*
*/
public class HelloWorldAsyncServiceTest {
private HelloWorldAsyncService service;
@Before
public void setup() {
this.service = new HelloWorldAsyncServiceImpl("Tester");
}
@Test
public void crudTest() throws Exception {
// create a new person, check they have no id
final Person person = new Person("Mr Noddy");
assertNull(person.getId());
// save it and check the id is set
final String id = firstFrom(testSubscriptionOn(service.createPerson(person)));
assertNotNull(id);
// read the person back and check the details
final Person read = firstFrom(testSubscriptionOn(this.service.readPerson(id)));
assertNotNull(read);
assertEquals(person.getName(), read.getName());
assertEquals(read.getUpdatedBy(), "Tester");
// capture the date, we'll check again after update
final Date createDate = read.getUpdatedAt();
assertNotNull(createDate);
// update and check its worked
read.setName("Mr Plod");
final Person updated = firstFrom(testSubscriptionOn(this.service.updatePerson(read)));
assertNotNull(updated);
assertEquals(read.getId(), updated.getId());
assertEquals(read.getName(), updated.getName());
assertNotEquals(createDate, updated.getUpdatedAt());
// delete and check it's gone
testSubscriptionOn(this.service.deletePerson(updated.getId()));
final Person deleted = firstFrom(testSubscriptionOn(this.service.readPerson(updated.getId())));
assertNull(deleted);
}
} | true |
39d53b715758b58d82921672e85de5ee3a5d28ab | Java | ShinhwanKim/ArchiWebstream | /app/src/main/java/com/example/webstream/HttpConnection.java | UTF-8 | 13,527 | 2.421875 | 2 | [] | no_license | package com.example.webstream;
import android.util.Log;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
public class HttpConnection {
private OkHttpClient client;
private static HttpConnection instance = new HttpConnection();
public static HttpConnection getInstance() {
return instance;
}
private HttpConnection(){ this.client = new OkHttpClient(); }
/** ์น ์๋ฒ๋ก ์์ฒญ์ ํ๋ค. */
public void requestWebServer(String parameter, Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("parameter", parameter)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestCheckId(String parameter,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("InputId", parameter)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestCheckNickname(String parameter,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("InputNickname", parameter)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestCheckPassword(String parameter,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("InputPassword", parameter)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestSignup(String parameter,String parameter2,String parameter3,String parameter4,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("InputId", parameter)
.add("InputPassword", parameter2)
.add("InputNickname", parameter3)
.add("InputEmail", parameter4)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestGetUserData(String parameter,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("InputId", parameter)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestLogin(String parameter, String parameter2, Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("InputId", parameter)
.add("InputPassword", parameter2)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestChaneNickname(String parameter,String parameter2, Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("id", parameter)
.add("InputNickname", parameter2)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestChanePassword(String id,String existingPassword, String newPassword,String newPasswordReconfirm, Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("id", id)
.add("existingPassword", existingPassword)
.add("newPassword",newPassword)
.add("newPasswordReconfirm",newPasswordReconfirm)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestChangeProfile(String parameter,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("InputId", parameter)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestChangeAlbumProfile(String id,String profileRoute,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("id", id)
.add("profileRoute", profileRoute)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestUpdateViewer(String routeStream,int viewer,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("routeStream", routeStream)
.add("viewer", String.valueOf(viewer))
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestCreateRecordChatTable(String routeStream,long startTime,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("routeStream", routeStream)
.add("startTime", String.valueOf(startTime))
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestSaveChatContent(String routeStream,String nickname, String content,long startTime,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("routeStream", routeStream)
.add("nickname", nickname)
.add("content", content)
.add("startTime", String.valueOf(startTime))
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestGetChatRecorded(String routeStream,Callback callback,String url){
RequestBody body = new FormBody.Builder()
.add("routeStream", routeStream)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestBoardWrite(String postData, String contentData, Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("postContent", postData)
.add("content",contentData)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestGetBoard(String postNumber, Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("postNumber", postNumber)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestLike(String postNumber,String flag, Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("postNumber", postNumber)
.add("flag", flag)
.add("loginedId",HomeActivity.loginedUser)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestLikeList(String postNumber, Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("postNumber", postNumber)
.add("loginedId",HomeActivity.loginedUser)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestProjectList(String param, int param2,String currentUser,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("param", param)
.add("startIndex",String.valueOf(param2))
.add("currentUser", currentUser)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestProjectListChannel(String param,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("targetId", param)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestRecordListChannel(String param,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("targetId", param)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestBroadListChannel(String param,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("targetId", param)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestSendSubscribe(String writter,String userId,String flag,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("writter", writter)
.add("userId", userId)
.add("flag", flag)
.build();
Log.e("TAG","http : "+flag);
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestGetSubscriberList(String userId,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("userId", userId)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestSubscriberProjectList(String targetId,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("targetId", targetId)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestHomeProjectList(Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestHomeLiveList(Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestHomeRecordList(Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
public void requestRemovePost(String targetPostNumber,Callback callback,String url) {
RequestBody body = new FormBody.Builder()
.add("targetPostNumber",targetPostNumber)
.build();
Request request = new Request.Builder()
.url(url)
.post(body)
.build();
client.newCall(request).enqueue(callback);
}
}
| true |
0690afcc35110bfc8fc9aaa8931b86066325e3f6 | Java | jshvarts/ShoppingList | /app/src/main/java/com/jshvarts/shoppinglist/di/AppModule.java | UTF-8 | 1,030 | 2.140625 | 2 | [] | no_license | package com.jshvarts.shoppinglist.di;
import android.app.Application;
import android.content.Context;
import com.jshvarts.shoppinglist.App;
import com.jshvarts.shoppinglist.common.domain.model.ShoppingListDataHelper;
import com.jshvarts.shoppinglist.common.domain.model.firebase.FirebaseShoppingListRepository;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
/**
* This is where you will inject application-wide dependencies.
*/
@Module
public class AppModule {
@Provides
Context provideContext(App application) {
return application.getApplicationContext();
}
@Provides
Application provideApplication(App application) {
return application;
}
@Singleton
@Provides
FirebaseShoppingListRepository provideFirebaseShoppingListRepository() {
return new FirebaseShoppingListRepository();
}
@Singleton
@Provides
ShoppingListDataHelper provideShoppingListDataHelper() {
return new ShoppingListDataHelper();
}
}
| true |
d17fe86c5ff6ae0a06d5801ee702a726afe1f5f5 | Java | RyanTech/pps_android | /Jiangqq_NewPractice/src/com/pps/utils/ZipToFile.java | UTF-8 | 5,710 | 3 | 3 | [] | no_license | package com.pps.utils;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;
/**
* ่งฃๅZIPๅ็ผฉๆไปถๅฐๆๅฎ็็ฎๅฝ
* @author jiangqq
* @since 2013-9 8:57:18
*/
public final class ZipToFile {
/**
* ็ผๅญๅบๅคงๅฐ้ป่ฎค20480
*/
private final static int FILE_BUFFER_SIZE = 20480;
private ZipToFile() {
}
/**
* ๅฐๆๅฎ็ฎๅฝ็ZIPๅ็ผฉๆไปถ่งฃๅๅฐๆๅฎ็็ฎๅฝ
* @param zipFilePath ZIPๅ็ผฉๆไปถ็่ทฏๅพ
* @param zipFileName ZIPๅ็ผฉๆไปถๅๅญ
* @param targetFileDir ZIPๅ็ผฉๆไปถ่ฆ่งฃๅๅฐ็็ฎๅฝ
* @return flag ๅธๅฐ่ฟๅๅผ
*/
public static boolean unzip(String zipFilePath, String zipFileName, String targetFileDir){
boolean flag = false;
//1.ๅคๆญๅ็ผฉๆไปถๆฏๅฆๅญๅจ๏ผไปฅๅ้้ข็ๅ
ๅฎนๆฏๅฆไธบ็ฉบ
File file = null; //ๅ็ผฉๆไปถ(ๅธฆ่ทฏๅพ)
ZipFile zipFile = null;
file = new File(zipFilePath + "/" + zipFileName);
System.out.println(">>>>>>่งฃๅๆไปถใ" + zipFilePath + "/" + zipFileName + "ใๅฐใ" + targetFileDir + "ใ็ฎๅฝไธ<<<<<<");
if(false == file.exists()) {
System.out.println(">>>>>>ๅ็ผฉๆไปถใ" + zipFilePath + "/" + zipFileName + "ใไธๅญๅจ<<<<<<");
return false;
} else if(0 == file.length()) {
System.out.println(">>>>>>ๅ็ผฉๆไปถใ" + zipFilePath + "/" + zipFileName + "ใๅคงๅฐไธบ0ไธ้่ฆ่งฃๅ<<<<<<");
return false;
} else {
//2.ๅผๅง่งฃๅZIPๅ็ผฉๆไปถ็ๅค็
byte[] buf = new byte[FILE_BUFFER_SIZE];
int readSize = -1;
ZipInputStream zis = null;
FileOutputStream fos = null;
try {
// ๆฃๆฅๆฏๅฆๆฏzipๆไปถ
zipFile = new ZipFile(file);
zipFile.close();
// ๅคๆญ็ฎๆ ็ฎๅฝๆฏๅฆๅญๅจ๏ผไธๅญๅจๅๅๅปบ
File newdir = new File(targetFileDir);
if (false == newdir.exists()) {
newdir.mkdirs();
newdir = null;
}
zis = new ZipInputStream(new FileInputStream(file));
ZipEntry zipEntry = zis.getNextEntry();
// ๅผๅงๅฏนๅ็ผฉๅ
ๅ
ๆไปถ่ฟ่กๅค็
while (null != zipEntry) {
String zipEntryName = zipEntry.getName().replace('\\', '/');
//ๅคๆญzipEntryๆฏๅฆไธบ็ฎๅฝ๏ผๅฆๆๆฏ๏ผๅๅๅปบ
if(zipEntry.isDirectory()) {
int indexNumber = zipEntryName.lastIndexOf('/');
File entryDirs = new File(targetFileDir + "/" + zipEntryName.substring(0, indexNumber));
entryDirs.mkdirs();
entryDirs = null;
} else {
try {
fos = new FileOutputStream(targetFileDir + "/" + zipEntryName);
while ((readSize = zis.read(buf, 0, FILE_BUFFER_SIZE)) != -1) {
fos.write(buf, 0, readSize);
}
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e.getCause());
} finally {
try {
if (null != fos) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e.getCause());
}
}
}
zipEntry = zis.getNextEntry();
}
flag = true;
} catch (ZipException e) {
e.printStackTrace();
throw new RuntimeException(e.getCause());
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e.getCause());
} finally {
try {
if (null != zis) {
zis.close();
}
if (null != fos) {
fos.close();
}
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e.getCause());
}
}
}
return flag;
}
/**
* ๆต่ฏ็จ็Mainๆนๆณ
*/
public static void main(String[] args) {
String zipFilePath = "C:\\home";
String zipFileName = "141.xml.zip";
String targetFileDir = "C:\\home\\141.xml";
boolean flag = ZipToFile.unzip(zipFilePath, zipFileName, targetFileDir);
if(flag) {
System.out.println(">>>>>>่งฃๅๆๅ<<<<<<");
} else {
System.out.println(">>>>>>่งฃๅๅคฑ่ดฅ<<<<<<");
}
}
} | true |
1bb37570e1bb589f21a2b41ed8bcc09872f4f28b | Java | Nuglib/leyou | /leyou-item/leyou-item-interface/src/main/java/com/leyou/item/bo/SpuBo.java | UTF-8 | 515 | 2 | 2 | [] | no_license | package com.leyou.item.bo;
import com.leyou.item.pojo.Spu;
/**
* @Author:jesse
* @Description:
* @Date:Create in 21:38 2018/10/24
* @Modified By:
*/
public class SpuBo extends Spu {
private String cname;
private String bname;
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
public String getBname() {
return bname;
}
public void setBname(String bname) {
this.bname = bname;
}
}
| true |
0d51bc6eb92163c6d1fff12d8e8b575256a15696 | Java | Lifesorted/Grestapi | /src/test/java/com/Gorest/Test/CreateUserApiTest.java | UTF-8 | 4,080 | 2.046875 | 2 | [] | no_license | package com.Gorest.Test;
import java.util.HashMap;
import java.util.Map;
import org.hamcrest.core.IsEqual;
import org.json.simple.JSONObject;
import org.testng.Assert;
import org.testng.annotations.Test;
import com.Gorest.Base.BaseClass;
import com.Gorest.apiConfig.APIPath;
import com.Gorest.apiConfig.HeaderConfig;
import com.Gorest.utils.GenerateUniqueValues;
import com.Gorest.utils.Getdata;
import io.restassured.RestAssured;
import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import io.restassured.response.ResponseBodyExtractionOptions;
import io.restassured.response.ValidatableResponse;
import io.restassured.specification.RequestSpecification;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
public class CreateUserApiTest extends BaseClass {
@Test
public void postDataApi() {
Map<String, String> createuserpayload= new HashMap<>();
createuserpayload.put("name", GenerateUniqueValues.getUniqueName());
createuserpayload.put("gender", "Female");
createuserpayload.put("email", GenerateUniqueValues.getUniqueName()+"@gmail.com");
createuserpayload.put("status", "Active");
RequestSpecification requestSpecification=RestAssured.given().headers(HeaderConfig.getDefaultHeader())
.auth().oauth2(Getdata.getPropertyData().get("Token")).body(createuserpayload);
Response response=requestSpecification.post(APIPath.ApiPaths.CREATE_USER);
JsonPath responsejsondata=response.jsonPath();
System.out.println(responsejsondata.prettyPrint());
String codeval=responsejsondata.getString("code");
System.out.println("Response code value:"+codeval);
Assert.assertEquals("201", codeval);
String metaval=responsejsondata.getString("meta");
System.out.println("Response meta value:"+metaval);
Assert.assertEquals(null, metaval);
String id=responsejsondata.getString("data.id");
System.out.println("Response id value:"+id);
}
@Test
public void createApiwithoutAuth() {
Map<String, String> createuserpayload= new HashMap<>();
createuserpayload.put("name", GenerateUniqueValues.getUniqueName());
createuserpayload.put("gender", "Female");
createuserpayload.put("email", GenerateUniqueValues.getUniqueName()+"@gmail.com");
createuserpayload.put("status", "Active");
RequestSpecification requestSpecification=RestAssured.given().headers(HeaderConfig.getDefaultHeader()).body(createuserpayload);
Response response =requestSpecification.post(APIPath.ApiPaths.CREATE_USER);
JsonPath jsonPath=response.jsonPath();
System.out.println(response.body().asString());
String codevalString= jsonPath.getString("code");
System.out.println("Value of code without auth:"+codevalString);
Assert.assertEquals(codevalString, "401");
String metaString=jsonPath.getString("meta");
System.out.println("Value of meta withour auth:"+metaString);
String messageString=jsonPath.getString("data.message");
System.out.println("Value of message:"+messageString);
}
@Test
public void validateResponsseHeaders() {
Map<String, String> createuserpayload= new HashMap<>();
createuserpayload.put("name", GenerateUniqueValues.getUniqueName());
createuserpayload.put("gender", "Female");
createuserpayload.put("email", GenerateUniqueValues.getUniqueName()+"@gmail.com");
createuserpayload.put("status", "Active");
RequestSpecification requestSpecification=RestAssured.given().headers(HeaderConfig.getDefaultHeader())
.auth().oauth2("Token").body(createuserpayload);
Response response =requestSpecification.post(APIPath.ApiPaths.CREATE_USER);
JsonPath jsonPath=response.jsonPath();
System.out.println(response.body().asString());
String contenttype= response.contentType();
System.out.println("Content type is:"+contenttype);
Assert.assertEquals(contenttype, "application/json");
int statuscode=response.getStatusCode();
System.out.println("Value of status code:"+statuscode);
Assert.assertEquals(statuscode, 200);
long statusline=response.getTime();
System.out.println("Value of time taken in response:"+statusline);
}
}
| true |
16708ef2794dbdbd40c589e0ec422b01c3330fcb | Java | violetbp/NausicaaMod | /src/main/java/mcp/mobius/waila/api/IWailaDataAccessor.java | UTF-8 | 864 | 1.984375 | 2 | [
"WTFPL",
"MIT"
] | permissive | package mcp.mobius.waila.api;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.util.Vec3;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
public interface IWailaDataAccessor {
World getWorld();
EntityPlayer getPlayer();
Block getBlock();
int getBlockID();
int getMetadata();
TileEntity getTileEntity();
MovingObjectPosition getPosition();
Vec3 getRenderingPosition();
NBTTagCompound getNBTData();
int getNBTInteger(NBTTagCompound tag, String keyname);
double getPartialFrame();
ForgeDirection getSide();
}
| true |
894126899b824d2fba9bb6651d72b4591d8c8fd6 | Java | ntcarter/ARAMAPP | /ARAMAPP2/src/project/WriteFile.java | UTF-8 | 618 | 2.34375 | 2 | [] | no_license | package project;
import org.json.JSONArray;
import org.json.JSONObject;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class WriteFile {
public void WriteJSONFile(JSONObject obj) {
try {
JSONObject jsonObject;
jsonObject = obj;
FileWriter newFile = new FileWriter("ARAMRequest.json");
newFile.write(jsonObject.toString());
newFile.flush();
newFile.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| true |
131adb904a57c1a8447528cb50397e4620e92a3d | Java | neiky/udp-com | /src/main/java/de/neiky/udp/UdpReceiver.java | UTF-8 | 4,873 | 3.390625 | 3 | [] | no_license | package de.neiky.udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
/**
* A UdpReceiver class built to receive UDP messages.
*
* @author Michael Neike
*/
public class UdpReceiver implements Runnable {
private final int port;
private InetAddress address;
private Thread receiverThread;
private DatagramSocket socket;
private PacketHandler packetHandler;
private MessageHandler messageHandler;
/**
* Constructor for UdpReceiver. After constructing use
* {@link #setPacketHandler(PacketHandler)} to assign a packet handler to
* the receiver. Then start listening using {@link #start()}.
*
* @param port The port on which the receiver will listen.
*/
public UdpReceiver(int port) {
this.port = port;
}
public UdpReceiver(String address, int port) throws UnknownHostException {
this.port = port;
this.address = InetAddress.getByName(address);
}
/**
* Starts listening on the port given in the constructor.
*
* @return this UdpReceiver
* @throws SocketException if the socket could not be opened, or the socket could not
* bind to the specified local port.
*/
public UdpReceiver start() throws SocketException {
socket = new DatagramSocket(this.port, this.address);
receiverThread = new Thread(this);
receiverThread.start();
return this;
}
/**
* Sets a packet handler. {@link PacketHandler} is a functional interface
* providing the function {@link PacketHandler#handlePacket(DatagramPacket)}
* .
*
* @param packetHandler
* @return this UdpReceiver
*/
public UdpReceiver setPacketHandler(PacketHandler packetHandler) {
this.packetHandler = packetHandler;
return this;
}
/**
* Sets a message handler. {@link MessageHandler} is a functional interface
* providing the function {@link MessageHandler#handleMessage(InetAddress, int, String)}
* .
*
* @param messageHandler
* @return this UdpReceiver
*/
public UdpReceiver setMessageHandler(MessageHandler messageHandler) {
this.messageHandler = messageHandler;
return this;
}
/**
* Stop listening for messages.
*
*/
public void stop() {
receiverThread.interrupt();
socket.close();
}
@Override
public void run() {
while (!Thread.interrupted()) {
DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
try {
// wait for next packet
// the thread is blocking while waiting...
socket.receive(packet);
if (this.packetHandler != null) {
this.packetHandler.handlePacket(packet);
}
if (this.messageHandler != null) {
InetAddress address = packet.getAddress();
int port = packet.getPort();
int len = packet.getLength();
byte[] data = packet.getData();
String receivedMessage = new String(data, 0, len);
this.messageHandler.handleMessage(address, port, receivedMessage);
}
if (this.packetHandler == null && this.messageHandler == null) {
System.err.println("Neither OnPacketReceive nor OnMessageReceive have been set!");
}
} catch (IOException e) {
System.err.println(e.getMessage());
}
}
}
/**
* Functional interface to handle a {@link DatagramPacket}, that are
* received by the {@link UdpReceiver}.
*
* @author Michael Neike
*/
@FunctionalInterface
interface PacketHandler {
/**
* Handle the received {@link DatagramPacket}.
*
* @param packet
*/
void handlePacket(DatagramPacket packet);
}
/**
* Functional interface to handle a {@link DatagramPacket}, that are
* received by the {@link UdpReceiver}.
*
* @author Michael Neike
*/
@FunctionalInterface
interface MessageHandler {
/**
* Handle the received {@link DatagramPacket}.
*
* @param senderAddress The remote address of the sender.
* @param senderPort The remote port of the sender.
* @param message The message.
*/
void handleMessage(InetAddress senderAddress, int senderPort, String message);
}
}
| true |
c1d0e8b9ac605c66a4420fb4ecab096136e43938 | Java | flymoon123/repo1 | /Fulei/src/Father.java | UTF-8 | 167 | 2.890625 | 3 | [] | no_license |
public class Father {
private String name = "zhangjun";
class Child {
public void introFather() {
System.out.println("My Father's name is " + name);
}
}
}
| true |
6385cb250c88504cbb2289cd804a44ba3e2b1826 | Java | bazelbuild/bazel | /src/main/java/com/google/devtools/build/lib/rules/cpp/CcNativeLibraryInfo.java | UTF-8 | 3,701 | 1.84375 | 2 | [
"Apache-2.0"
] | permissive | // Copyright 2014 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.rules.cpp;
import com.google.common.collect.Iterables;
import com.google.devtools.build.lib.collect.nestedset.Depset;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.collect.nestedset.Order;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.packages.BuiltinProvider;
import com.google.devtools.build.lib.packages.NativeInfo;
import com.google.devtools.build.lib.starlarkbuildapi.cpp.CcNativeLibraryInfoApi;
import java.util.List;
import net.starlark.java.eval.EvalException;
/**
* A target that provides native libraries in the transitive closure of its deps that are needed for
* executing C++ code.
*/
@Immutable
public final class CcNativeLibraryInfo extends NativeInfo implements CcNativeLibraryInfoApi {
public static final CcNativeLibraryInfo EMPTY =
new CcNativeLibraryInfo(NestedSetBuilder.emptySet(Order.LINK_ORDER));
private final NestedSet<LibraryToLink> transitiveCcNativeLibraries;
public static final Provider PROVIDER = new Provider();
public CcNativeLibraryInfo(NestedSet<LibraryToLink> transitiveCcNativeLibraries) {
this.transitiveCcNativeLibraries = transitiveCcNativeLibraries;
}
@Override
public Provider getProvider() {
return PROVIDER;
}
/**
* Collects native libraries in the transitive closure of its deps that are needed for executing
* C/C++ code.
*
* <p>In effect, returns all dynamic library (.so) artifacts provided by the transitive closure.
*/
public NestedSet<LibraryToLink> getTransitiveCcNativeLibraries() {
return transitiveCcNativeLibraries;
}
/** Merge several CcNativeLibraryInfo objects into one. */
public static CcNativeLibraryInfo merge(List<CcNativeLibraryInfo> providers) {
if (providers.isEmpty()) {
return EMPTY;
} else if (providers.size() == 1) {
return Iterables.getOnlyElement(providers);
}
NestedSetBuilder<LibraryToLink> transitiveCcNativeLibraries = NestedSetBuilder.linkOrder();
for (CcNativeLibraryInfo provider : providers) {
transitiveCcNativeLibraries.addTransitive(provider.getTransitiveCcNativeLibraries());
}
return new CcNativeLibraryInfo(transitiveCcNativeLibraries.build());
}
/** Provider class for {@link CcNativeLibraryInfo} objects */
public static class Provider extends BuiltinProvider<CcNativeLibraryInfo>
implements CcNativeLibraryInfoApi.Provider {
private Provider() {
super(CcNativeLibraryInfoApi.NAME, CcNativeLibraryInfo.class);
}
@Override
public CcNativeLibraryInfo createCcNativeLibraryInfo(Object librariesToLinkObject)
throws EvalException {
NestedSet<LibraryToLink> librariesToLink =
Depset.cast(librariesToLinkObject, LibraryToLink.class, "libraries_to_link");
if (librariesToLink.isEmpty()) {
return EMPTY;
}
return new CcNativeLibraryInfo(librariesToLink);
}
}
}
| true |
60e1d8c057dc680f4f17754715c0f8e6f2ec365b | Java | wuziliang18/springlearn | /spirngboot/src/main/java/com/wuzl/learn/spring/boot/service/CompanyService.java | UTF-8 | 259 | 2.125 | 2 | [] | no_license | package com.wuzl.learn.spring.boot.service;
import org.springframework.stereotype.Service;
@Service
public class CompanyService {
public String getByName(String name) {
System.out.println("CompanyService getByName");
return name + "ๆ้ๅ
ฌๅธ";
}
}
| true |
fa571281d3876eb39812769c60acf31d370f9775 | Java | Cuscatlan/Renta | /src/main/java/net/cuscatlan/controller/RentpersonaController.java | UTF-8 | 5,006 | 1.75 | 2 | [] | no_license | package net.cuscatlan.controller;
import java.util.List;
import net.cuscatlan.common.ObjectUtils;
import net.cuscatlan.common.JqgridFilter;
import net.cuscatlan.common.JqgridResponse;
import net.cuscatlan.domain.Rentpersona;
import net.cuscatlan.repository.RentpersonaRepository;
import net.cuscatlan.poi.LayOutDynamic;
import net.cuscatlan.poi.Writer;
import javax.servlet.http.HttpServletResponse;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import java.util.ArrayList;
import net.cuscatlan.common.CboFilter;
import java.util.Date;
@Controller
@RequestMapping("/")
public class RentpersonaController {
@Autowired
RentpersonaRepository rentpersonaRepository;
@RequestMapping("/indexRentpersona")
public ModelAndView indexRentpersona(){
ModelAndView mv = new ModelAndView();
mv.addObject("rentpersona", new Rentpersona());
mv.setViewName("Rentpersona/Rentpersona.jsp");
return mv;
}
@RequestMapping(value = "/saveRentpersona", method = RequestMethod.POST)
public @ResponseBody String saveRentpersona(@ModelAttribute("Rentpersona") @Validated Rentpersona rentpersona ) {
rentpersonaRepository.save(rentpersona);
return null;
}
@RequestMapping(value = "/deleteRentpersona", method = RequestMethod.POST)
public @ResponseBody String deleteRentpersona(@ModelAttribute("Rentpersona") Rentpersona rentpersona ) {
rentpersonaRepository.delete(rentpersona);
return null;
}
@RequestMapping(value = "/gridRentpersona", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
public @ResponseBody JqgridResponse<Rentpersona> gridRentpersona(
@RequestParam(value = "filters", required = false) String filters,
@RequestParam(value = "page", required = false) Integer page,
@RequestParam(value = "rows", required = false) Integer rows
) {
Page<Rentpersona> list = rentpersonaRepository.findByFilters(
new PageRequest(page - 1, rows)
,JqgridFilter.getField(filters, "idpersona")
,JqgridFilter.getField(filters, "nombrepersona")
,JqgridFilter.getField(filters, "duipersona")
,JqgridFilter.getField(filters, "apellidopersona")
);
JqgridResponse<Rentpersona> jqgridRentpersona = new JqgridResponse<Rentpersona>();
return jqgridRentpersona.jGridFill(list, page, rows);
}
@RequestMapping(value = "/exportRentpersona", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
public void exportRentpersona(
HttpServletResponse response,@RequestParam(value = "filters", required = false) String filters
) {
HSSFWorkbook workbook = new HSSFWorkbook();
HSSFSheet worksheet = workbook.createSheet("libro");
List<String> header = new ArrayList<String>();
header.add("idpersona");
header.add("nombrepersona");
header.add("duipersona");
header.add("apellidopersona");
LayOutDynamic.buildReport(worksheet, "Rentpersona", header);
List<Object[]> list = rentpersonaRepository.findByFilters(
JqgridFilter.getField(filters, "idpersona")
,JqgridFilter.getField(filters, "nombrepersona")
,JqgridFilter.getField(filters, "duipersona")
,JqgridFilter.getField(filters, "apellidopersona")
);
LayOutDynamic.fillReport(worksheet, header.size(),list);
String fileName = "Rentpersona.xls";
response.setHeader("Content-Disposition", "inline; filename=" + fileName);
response.setContentType("application/vnd.ms-excel");
Writer.write(response, worksheet);
}
@RequestMapping(value = {"/cbofilterRentpersona"}, method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
public @ResponseBody List<CboFilter> cbofilterRentpersona() {
List<Rentpersona> list = rentpersonaRepository.findAll();
List<CboFilter> response = new ArrayList<CboFilter>();
for (int i = 0; i < list.size(); i++) {
response.add(new CboFilter(list.get(i).getIdpersona().toString(), list.get(i).getIdpersona().toString()));
}
return response;
}
}
| true |
d487cc5c0968d5416b420d3174580b954874be64 | Java | lixiawss/fd-j | /feidao-service-workflow/src/main/java/com/feidao/platform/service/workflow/query/VariablesQueryResultMapper.java | UTF-8 | 3,431 | 2.6875 | 3 | [] | no_license | package com.feidao.platform.service.workflow.query;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dashbuilder.dataset.DataColumn;
import org.dashbuilder.dataset.DataSet;
import org.jbpm.services.api.query.QueryResultMapper;
/**
* ๅธฆๅๆฐๅๆฅ่ฏข็ปๆ็ป่ฃ
ๅจ๏ผ็ป่ฃ
ๆฐๆฎๆถ๏ผ็ธๅไธป้ฎๅผ็ๆฐๆฎไผๅๅนถๆไธไธชMap๏ผ็ถๅๆ่ฟไบ็ธๅไธป้ฎๅผ็ๆฐๆฎ็vname็ๅผไฝไธบkey๏ผvvalueไฝไธบvalue็ๆไธไธชMapๅญๅจๅจvariables่ฟไธชkey้
*
* @user fengrh
* @provider fengrh
* @purpose
* @author fengrh
*
*/
@SuppressWarnings("serial")
public class VariablesQueryResultMapper extends AbstractQueryMapper<Map<String, Object>> implements QueryResultMapper<List<Map<String, Object>>> {
private final QueryResultMapperKeyGenerator<?> keyGenerator;
private final String var_name;
private final String var_value;
public VariablesQueryResultMapper(QueryResultMapperKeyGenerator<?> keyGenerator,String vname,String vvalue){
this.keyGenerator = keyGenerator;
this.var_name = vname;
this.var_value = vvalue;
}
@SuppressWarnings("unchecked")
@Override
public List<Map<String, Object>> map(Object result) {
if (result instanceof DataSet) {
DataSet dataSetResult = (DataSet) result;
List<Map<String, Object>> mappedResult = new ArrayList<Map<String, Object>>();
Map<Object, Map<String, Object>> tmp = new HashMap<Object, Map<String, Object>>();
if (dataSetResult != null) {
int size = dataSetResult.getRowCount();
Map<String, Object> data;
Map<String, String> vars;
for (int i = 0; i < size; i++) {
Object key = keyGenerator.generateKey(dataSetResult, i);
data = tmp.get(key);
if(data == null){
data = buildInstance(dataSetResult, i);
vars = new HashMap<String, String>();
data.put("variables", vars);
mappedResult.add(data);
tmp.put(key, data);
} else {
vars = (Map<String, String>) data.get("variables");
}
vars.put(getColumnStringValue(dataSetResult, var_name, i), getColumnStringValue(dataSetResult, var_value, i));
data.remove(var_name);
data.remove(var_value);
}
}
return mappedResult;
}
throw new IllegalArgumentException("Unsupported result for mapping " + result);
}
@Override
public String getName() {
return "SimpleQueryResultMapper";
}
@Override
public Class<?> getType() {
return VariablesQueryResultMapper.class;
}
@Override
public QueryResultMapper<List<Map<String, Object>>> forColumnMapping(
Map<String, String> columnMapping) {
return new VariablesQueryResultMapper(null,null,null);
}
@Override
protected Map<String, Object> buildInstance(DataSet dataSetResult, int index) {
Map<String, Object> data = new HashMap<String, Object>();
List<DataColumn> columns = dataSetResult.getColumns();
for (DataColumn dataColumn : columns) {
data.put(dataColumn.getId(), dataColumn.getValues().get(index));
}
return data;
}
public interface QueryResultMapperKeyGenerator<T>{
public T generateKey(DataSet dataset,int index);
}
}
| true |
c7d53817aa1e1374a8fcfd6cc0672ef5239cb731 | Java | serdaralkancode/java-features-examples | /src/main/java/tr/salkan/code/java/pure/examples/complexity/QuadraticTimeComplexity.java | UTF-8 | 1,088 | 3.765625 | 4 | [] | no_license | package tr.salkan.code.java.pure.examples.complexity;
public class QuadraticTimeComplexity {
/*
- O(nยฒ)
- Examples
Bubble Sort
Insertion Sort
Selection Sort
Traversing a simple 2D array
*/
// Bubble Sort
void bubbleSorting(int arr[])
{
int n = arr.length;
for (int i = 0; i < n-1; i++)
for (int j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
// Insertion Sort
void insertionSorting(int arr[])
{
int n = arr.length;
for (int i = 1; i < n; ++i) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
public static void main(String[] args) {
}
}
| true |
75bb300ccaab1734115d013834e954593bc4673e | Java | logidasakthi/demo | /Arm.java | UTF-8 | 391 | 3.3125 | 3 | [] | no_license | import java.util.*;
class Arm{
public static void main(String args[]){
Scanner s=new Scanner(System.in);
int n;
int x,y;
int sum=0;
System.out.println("enter the number");
n=s.nextInt();
y=n;
while(n>0)
{
x=n%10;
sum=sum+(x*x*x);
n=n/10;
}
if(y==sum)
{
System.out.println("the no. is armstrong");
}
else{
System.out.println("the no.is not armstrong");
}
}
}
| true |
9d223daa0037e1469e22c77f541a4dede0fcbb5b | Java | IsmaelVaz/ChinaeCia | /Backup-China e CIA/restaurantechinaecia/src/br/com/restaurantechinaecia/controller/BorderFuncionarioController.java | UTF-8 | 1,143 | 2.21875 | 2 | [] | no_license | package br.com.restaurantechinaecia.controller;
import java.net.URL;
import java.util.ResourceBundle;
import br.com.restaurantechinaecia.view.MainChinaCia;
import javafx.fxml.*;
import javafx.scene.control.MenuItem;
public class BorderFuncionarioController implements Initializable{
@FXML
MenuItem itemCodigos, itemDespesasDia, itemLoginEntrar, itemCliente;
MainChinaCia main;
@Override
public void initialize(URL arg0, ResourceBundle arg1) {
// TODO Auto-generated method stub
itemCodigos.setOnAction(l-> CarregarMesa());
itemDespesasDia.setOnAction(l->CarregarDespesasDia());
itemLoginEntrar.setOnAction(l-> LoginEntar());
itemCliente.setOnAction(l-> CarregarCliente());
}
public BorderFuncionarioController(MainChinaCia main) {
// TODO Auto-generated constructor stub
this.main=main;
}
public void CarregarMesa(){
main.CarregarMesas();
}
public void CarregarDespesasDia(){
main.CarregarDespesaDia();
}
public void LoginEntar(){
main.TelaLogin();
}
public void CarregarCliente(){
main.CarregarClientes();
}
public void LoginSair(){
main.TelaLogin();
}
}
| true |
0c974762e84c3d7328fa37b3b65b00a2946e3a61 | Java | azmym/Codility | /java/string/jewelsAndStones/Solution2.java | UTF-8 | 301 | 2.890625 | 3 | [] | no_license | package string.jewelsAndStones;
public class Solution2 {
public int numJewelsInStones(String jewels, String stones) {
int result= 0;
for(char stone : stones.toCharArray()){
if (jewels.contains(String.valueOf(stone))) result++;
}
return result;
}
}
| true |
133e4b71136afb3b191d84439c58be59555e8710 | Java | Shaz-Set/WeddingAppSpringboot | /src/main/java/com/yalda/WeddingAppSpringboot/service/WeddingPackagesService.java | UTF-8 | 965 | 2.25 | 2 | [] | no_license | package com.yalda.WeddingAppSpringboot.service;
import com.yalda.WeddingAppSpringboot.model.AddOn;
import com.yalda.WeddingAppSpringboot.model.DrinkPackage;
import com.yalda.WeddingAppSpringboot.model.WeddingPackage;
import java.util.List;
public interface WeddingPackagesService {
//get
List<WeddingPackage> getAllWeddingPackages();
List<DrinkPackage> getAllDrinkPackages();
List<AddOn> getAllAddOns();
//update
Long updateWeddingPackage(WeddingPackage weddingPackage);
Long updateDrinkPackage(DrinkPackage drinkPackage);
Long updateAddOn(AddOn addOn);
//delete
void deleteWeddingPackage(Long id);
void deleteDrinkPackage(Long id);
void deleteAddOn(Long id);
//find
WeddingPackage getWeddingPackageById(long id);
DrinkPackage getDrinkPackageById(long id);
AddOn getAddOnById(long id);
double calculateTotalPrice(double wpPrice, double dpPrice, double aoPrice, int guests);
}
| true |
c00be794fa824b447ed7b80e36c8cefd95a7d6fb | Java | babolat22/cotorras | /3ra Parte/Exepciones1/src/exepciones1/Try4.java | UTF-8 | 1,119 | 3.21875 | 3 | [] | 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 exepciones1;
public class Try4
{
public static void main(String arg[])
{
int [] array = new int[20];
try
{
// array[-3] = 24;
int b = 0;
int a = 23/b;
/*
String s = null;
s.equals("QQQQ");*/
}
catch(ArrayIndexOutOfBoundsException excepcion)
{
System.out.println(" Error de รญndice en un array");
}
catch(ArithmeticException e)
{
System.out.println(" Error Aritmetico: "+e);
}
catch(Exception excepcion)
{
System.out.println("Se ha generado un error que no es de รญndices, ni Aritmรฉtico");
System.out.println("El objeto error es de tipo " + excepcion);
excepcion.printStackTrace();
}
}
} | true |
0c2314e9f745ce32a2fcdc1421014145b22ab875 | Java | bangx2e/MVC07 | /src/kr/bit/controller/MemberListController.java | UTF-8 | 813 | 2.46875 | 2 | [] | no_license | package kr.bit.controller;
import java.io.IOException;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import kr.bit.model.MemberDAO;
import kr.bit.model.MemberVO;
public class MemberListController implements Controller{
@Override
public String requestHandler(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// POJO๊ฐ ํด์ผํ ์ผ์ ๋ฒ์
// 1. Model ์ฐ๋
MemberDAO dao=new MemberDAO();
List<MemberVO> list=dao.memberList();
// 2. ๊ฐ์ฒด๋ฐ์ธ๋ฉ
request.setAttribute("list", list);
// member/memberList.jsp
// ๋ค์ํ์ด์ง๋
// 3.๋ค์ํ์ด์ง์ ๋ณด(View)
return "memberList";
}
}
| true |
0c54e38a23640ba836385898d07a42c94d225f25 | Java | jzaoralek/Swimming-Club-Bohumin | /ruian-client/src/main/java/com/sportologic/ruianclient/model/RuianStreetResponse.java | UTF-8 | 355 | 2.3125 | 2 | [] | no_license | package com.sportologic.ruianclient.model;
import java.util.List;
public class RuianStreetResponse {
private List<RuianStreet> data;
public List<RuianStreet> getData() {
return data;
}
public void setData(List<RuianStreet> data) {
this.data = data;
}
@Override
public String toString() {
return "RuianStreet [data=" + data + "]";
}
}
| true |
e2f5b4e77db99b3199d105782b2fd01f89d1b78e | Java | busgo/fc | /fc-biz/src/main/java/com/busgo/fc/biz/spider/AbstractSpider.java | UTF-8 | 1,931 | 2.375 | 2 | [] | no_license | package com.busgo.fc.biz.spider;
import com.busgo.fc.biz.component.HouseComponent;
import com.busgo.fc.inner.dao.HouseDao;
import com.busgo.fc.inner.model.House;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
/**
* @author busgo
* @date 2019-11-19 15:36
*/
public abstract class AbstractSpider implements Spider {
private final static Logger log = LoggerFactory.getLogger(AbstractSpider.class);
@Resource
private HouseComponent houseComponent;
@Autowired
private HouseDao houseDao;
@Override
public void store(List<House> houseList) {
if (CollectionUtils.isEmpty(houseList)) return;
for (House house : houseList) {
try {
House h = this.houseComponent.findHouseByBizIdAndSource(house.getBizId(), house.getSource());
if (h == null) {
house.setCreateTime(new Date());
this.houseDao.insert(house);
log.info("ๆฟๅฑไฟกๆฏ:{},ๆๅ
ฅๆๅ", house);
} else {
if (h.getUpdateTime() != null && h.getUpdateTime().equals(house.getUpdateTime())) {
log.warn("ๆฟๅฑไฟกๆฏ:{},ๆชๅๅ", house);
continue;
}
house.setId(h.getId());
house.setModifyTime(new Date());
house.setSource(null);
house.setBizId(null);
this.houseDao.updateById(house);
log.info("ๆฟๅฑไฟกๆฏ:{},ๆดๆฐๆๅ", house);
}
} catch (Exception e) {
log.error("ๆฟๅฑไฟกๆฏ:{},ๅค็ๅคฑ่ดฅ", house, e);
}
}
}
}
| true |
ed4de4cbd8e65396e3724634b59e38f4e7f216c9 | Java | alexAvizhen/ClinicServer | /src/main/java/com/bsuir/lagunovskaya/clinic/server/dao/DoctorDAO.java | UTF-8 | 422 | 2.109375 | 2 | [] | no_license | package com.bsuir.lagunovskaya.clinic.server.dao;
import com.bsuir.lagunovskaya.clinic.communication.entity.Doctor;
import java.util.Collection;
public interface DoctorDAO {
Doctor getDoctorById(Integer id);
Doctor getDoctorByLogin(String login);
Doctor createDoctor(Doctor doctor);
void updateDoctor(Doctor doctor);
void deleteDoctorById(Integer id);
Collection<Doctor> getAllDoctors();
}
| true |
e64504c81ca5af4cd8f7ca9462c4ecd3ae695d65 | Java | djimenezc/logtrust | /task1/src/main/java/com/djimenezc/service/util/TimeUtil.java | UTF-8 | 1,349 | 3.1875 | 3 | [] | no_license | package com.djimenezc.service.util;
import java.util.Calendar;
import java.util.Date;
import java.util.Random;
/**
* Class to manage timestamps and dates
* Created by david on 10/07/2016.
*/
public class TimeUtil {
/**
* Return a random date since 2012 to nowadays
* @return random date
*/
public static Date getRandomTimestamp() {
Random r = new Random();
long unixTime = (long) (1293861599 + r.nextDouble() * 60 * 60 * 24 * 365);
return new Date(unixTime);
}
/**
* Return a date between now and <code>seconds</code> ago
*
* @param seconds interval of seconds to return the date
* @return date
*/
public static Date getRandomTimestamp(int seconds) {
Date max = new Date();
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(max.getTime() - secondsToMs(seconds));
Date min = cal.getTime();
Random r = new Random();
long unixTime = r.nextInt((int) (max.getTime() - min.getTime())) + min.getTime();
return new Date(unixTime);
}
public static long secondsToMs(int seconds) {
return seconds * 1000;
}
public static boolean isWithinRange(Date testDate, Date startDate, Date endDate) {
return !(testDate.before(startDate) || testDate.after(endDate));
}
}
| true |
df6c2e1de18470d2397f3998f0511154c80f32fd | Java | cha63506/CompSecurity | /pinterest_source/src/com/pinterest/api/igresponse/IgPinFeedResponse.java | UTF-8 | 6,759 | 1.765625 | 2 | [] | no_license | // Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc
package com.pinterest.api.igresponse;
import com.pinterest.api.ApiResponse;
import com.pinterest.api.igmodel.IgPin;
import com.pinterest.api.model.Pin;
import com.pinterest.api.model.PinFeed;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
// Referenced classes of package com.pinterest.api.igresponse:
// IgResponse
public class IgPinFeedResponse extends IgResponse
{
protected List a;
protected List b;
public IgPinFeedResponse()
{
b = new ArrayList();
}
private PinFeed d()
{
PinFeed pinfeed = new PinFeed();
a(pinfeed);
ArrayList arraylist = new ArrayList();
Iterator iterator = b.iterator();
do
{
if (!iterator.hasNext())
{
break;
}
com.pinterest.api.model.Pin.PinArtifact pinartifact = (com.pinterest.api.model.Pin.PinArtifact)iterator.next();
Pin pin = pinartifact.getPin();
if (pin != null && "pin".equals(pin.getType()))
{
arraylist.add(pinartifact.getPin());
}
} while (true);
pinfeed.setItems(arraylist);
pinfeed.setData(null);
return pinfeed;
}
public final void a()
{
if (a != null)
{
com.pinterest.api.model.Pin.PinArtifact pinartifact;
for (Iterator iterator = a.iterator(); iterator.hasNext(); b.add(pinartifact))
{
pinartifact = ((IgPin)iterator.next()).a();
}
}
}
public final void b()
{
(new _cls1()).execute();
}
public final ApiResponse c()
{
return d();
}
private class _cls1 extends BackgroundTask
{
final IgPinFeedResponse a;
public void run()
{
Object obj5 = new ArrayList();
Object obj4 = new ArrayList();
Object obj3 = new ArrayList();
Object obj1 = new ArrayList();
Object obj = new ArrayList();
ArrayList arraylist = new ArrayList();
ArrayList arraylist1 = new ArrayList();
ArrayList arraylist2 = new ArrayList();
ArrayList arraylist3 = new ArrayList();
Object obj2 = new ArrayList();
Iterator iterator = a.b.iterator();
do
{
if (!iterator.hasNext())
{
break;
}
com.pinterest.api.model.Pin.PinArtifact pinartifact = (com.pinterest.api.model.Pin.PinArtifact)iterator.next();
if (pinartifact.getPin() != null)
{
((List) (obj2)).add(pinartifact.getPin());
((List) (obj5)).add(pinartifact.getPin().getUid());
}
if (pinartifact.getBoard() != null)
{
((List) (obj1)).add(pinartifact.getBoard());
((List) (obj4)).add(pinartifact.getBoard().getUid());
}
if (pinartifact.getRecommendationBoard() != null)
{
((List) (obj1)).add(pinartifact.getRecommendationBoard());
((List) (obj4)).add(pinartifact.getRecommendationBoard().getUid());
}
if (pinartifact.getRecommendationPin() != null)
{
((List) (obj2)).add(pinartifact.getRecommendationPin());
((List) (obj5)).add(pinartifact.getRecommendationPin().getUid());
}
if (pinartifact.getRecommendationInterest() != null)
{
arraylist2.add(pinartifact.getRecommendationInterest());
}
if (pinartifact.getUser() != null)
{
((List) (obj)).add(pinartifact.getUser());
((List) (obj3)).add(pinartifact.getUser().getUid());
if (pinartifact.getUser().getPartner() != null)
{
arraylist.add(pinartifact.getUser().getPartner());
}
}
if (pinartifact.getPromoterUser() != null)
{
((List) (obj)).add(pinartifact.getPromoterUser());
((List) (obj3)).add(pinartifact.getPromoterUser().getUid());
if (pinartifact.getPromoterUser().getPartner() != null)
{
arraylist.add(pinartifact.getPromoterUser().getPartner());
}
}
if (pinartifact.getViaUser() != null)
{
((List) (obj)).add(pinartifact.getViaUser());
((List) (obj3)).add(pinartifact.getViaUser().getUid());
if (pinartifact.getViaUser().getPartner() != null)
{
arraylist.add(pinartifact.getViaUser().getPartner());
}
}
if (pinartifact.getPlace() != null)
{
arraylist1.add(pinartifact.getPlace());
}
if (pinartifact.getSourceInterest() != null)
{
arraylist2.add(pinartifact.getSourceInterest());
}
if (pinartifact.getDomainObj() != null)
{
arraylist3.add(pinartifact.getDomainObj());
if (pinartifact.getDomainObj() != null)
{
((List) (obj)).add(pinartifact.getDomainObj().getOfficialUser());
}
}
} while (true);
obj5 = ModelHelper.getPins(((List) (obj5)));
obj4 = ModelHelper.getBoards(((List) (obj4)));
obj3 = ModelHelper.getUsers(((List) (obj3)));
obj2 = Pin.mergeAll(((List) (obj2)), ((List) (obj5)));
obj1 = Board.mergeAll(((List) (obj1)), ((List) (obj4)));
obj = User.mergeAll(((List) (obj)), ((List) (obj3)));
ModelHelper.setPins(((List) (obj2)));
ModelHelper.setBoards(((List) (obj1)));
ModelHelper.setPartners(arraylist);
ModelHelper.setUsers(((List) (obj)));
ModelHelper.setPlaces(arraylist1);
ModelHelper.setInterests(arraylist2);
ModelHelper.setDomains(arraylist3);
}
_cls1()
{
a = IgPinFeedResponse.this;
super();
}
}
}
| true |
3b48915e6bff66ef0ade09ef13e775dbde2006a0 | Java | SeongGwon2608/programmerscoding | /CodingTest/src/programmers_Lv2/MaxMin.java | UTF-8 | 767 | 3.546875 | 4 | [] | no_license | //๋ฌธ์ ๋ช
: ์ต๋๊ฐ๊ณผ ์ต์๊ฐ(์ฐ์ต๋ฌธ์ )
//๋์ด๋ : Lv2
//ํด๊ฒฐ์ผ : 20.08.24
//๋ธ๋ก๊ทธ : O
package programmers_Lv2;
import java.util.Arrays;
public class MaxMin {
public static void main(String[] args) {
String s = "1 2 3 4";
String s2 = "-1 -2 -3 -4";
String answer = solution(s2);
System.out.println("answer : " + answer);
}
public static String solution(String s) {
String[] arrStr = s.split(" ");
int[] nTemp = new int[arrStr.length];
for(int i=0; i<arrStr.length; i+=1) {
nTemp[i] = Integer.parseInt(arrStr[i]);
}
Arrays.sort(nTemp);
String answer = nTemp[0] + " " + nTemp[nTemp.length-1];
return answer;
}
}
| true |
19ac22b805c34e57db06e6dabff7b7bcc457c8f5 | Java | nugrohosam/springregion | /src/main/java/com/nugrohosamiyono/springregion/Validations/State/StateShouldbeExists.java | UTF-8 | 1,395 | 2.1875 | 2 | [] | no_license | package com.nugrohosamiyono.springregion.Validations.State;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import com.nugrohosamiyono.springregion.Applications.StateApplication;
import org.springframework.beans.factory.annotation.Autowired;
@Documented
@Constraint(validatedBy = StateValidatorShouldBeExists.class)
@Target({ ElementType.METHOD, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface StateShouldBeExists {
String message() default "Cannot Find State";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}
class StateValidatorShouldBeExists implements ConstraintValidator<StateShouldBeExists, Integer> {
@Autowired
StateApplication countryApplication;
@Override
public void initialize(StateShouldBeExists stateid) {
}
@Override
public boolean isValid(Integer stateid, ConstraintValidatorContext context) {
if (stateid == null) {
return false;
}
return this.countryApplication.detailState(stateid).getId() != null;
}
} | true |
c12592a7f9a0b92651c4cad302c26d530a570379 | Java | javierbarbe/rojo | /listasLibroLuisJose/rehechosListasDiccionarios/Ej9CartasordenadasSinRepetir.java | ISO-8859-2 | 249 | 1.515625 | 2 | [] | no_license | package rehechosListasDiccionarios;
public class Ej9CartasordenadasSinRepetir {
public static void main(String[] args) {
// TODO Apndice de mtodo generado automticamente
for( int i = 0; i<10;i++) {
}
}
}
| true |
02eca37ba2b2de0e046e8713c46ff87a5f80bd26 | Java | Braslynrr/Aerolinea | /src/main/java/aerolinea/presentacion/aรฑadirmetododepago/AรฑadirPagoController.java | UTF-8 | 1,501 | 2.265625 | 2 | [] | no_license | package aerolinea.presentacion.aรฑadirmetododepago;
import aerolinea.data.MetodoPagoDao;
import aerolinea.logic.MetodoPago;
import aerolinea.logic.Modelo;
import aerolinea.presentacion.pago.PagoController;
public class AรฑadirPagoController {
AรฑadirPagoView view;
AรฑadirPagoModel model;
PagoController pcontrol;
public AรฑadirPagoController(AรฑadirPagoModel model,AรฑadirPagoView view,PagoController pcontrol) {
this.model = model;
this.view = view;
view.setModel(model);
view.setController(this);
this.pcontrol = pcontrol;
}
public void Aรฑadir(MetodoPago object) throws Exception
{
// MetodoPagoDao.getInstance().create(object);
Modelo.getInstance().Aรฑadir(object);
model.setUser(object);
pcontrol.Update();
}
public void Modifcar(MetodoPago object) throws Exception
{
// MetodoPagoDao.getInstance().edit(object);
Modelo.getInstance().Modifcar(object);
model.setUser(object);
pcontrol.Update();
}
public void setPago(MetodoPago object)
{
view.codigofield.setText(String.valueOf(object.getCodigo()));
view.codigofield.setEnabled(false);
view.descripcionfield.setText(object.getDescripcion());
}
public void setvisible(boolean visible)
{
view.setVisible(visible);
}
public void OcultarDialogo()
{
pcontrol.OcutarDialogo();
}
}
| true |
bea277b9daa3cf7d9b3bfdd3f3097680543b154f | Java | aotdevelopments/HeadPod | /Headpodv1.0BUENA/app/src/main/java/com/siestasystemheadpod/headpodv10/adicionales/informe/MySurfaceView.java | UTF-8 | 4,159 | 2.484375 | 2 | [] | no_license | package com.siestasystemheadpod.headpodv10.adicionales.informe;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import com.siestasystemheadpod.headpodv10.R;
/**
* Subproceso para caragar los elemenos de la vista del InformeFragment
*/
public class MySurfaceView extends SurfaceView {
private SurfaceHolder surfaceHolder;
private Bitmap bmpIcon;
public MySurfaceView(Context context) {
super(context);
init(context);
}
public MySurfaceView(Context context,
AttributeSet attrs) {
super(context, attrs);
init(context);
}
public MySurfaceView(Context context,
AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init(context);
}
private void init(Context context) {
surfaceHolder = getHolder();
bmpIcon = BitmapFactory.decodeResource(getResources(),
R.drawable.rango_inclinacion_prueba);
surfaceHolder.addCallback(new SurfaceHolder.Callback() {
@Override
public void surfaceCreated(SurfaceHolder holder) {
Canvas canvas = holder.lockCanvas(null);
drawSomething(canvas);
holder.unlockCanvasAndPost(canvas);
}
@Override
public void surfaceChanged(SurfaceHolder holder,
int format, int width, int height) {
// TODO Auto-generated method stub
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
// TODO Auto-generated method stub
}
});
}
protected void drawSomething(Canvas canvas) {
canvas.drawColor(Color.BLACK);
canvas.drawBitmap(bmpIcon,
getWidth(), getHeight(), null);
}
}
/*
public class MySurfaceView extends SurfaceView implements
SurfaceHolder.Callback {
private TutorialThread _thread;
public MySurfaceView(Context context) {
super(context);
getHolder().addCallback(this);
_thread = new TutorialThread(getHolder(), this);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
Bitmap _scratch = BitmapFactory.decodeResource(getResources(),
R.drawable.g11_20);
canvas.drawColor(Color.BLACK);
canvas.drawBitmap(_scratch, 10, 10, null);
}
public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
}
public void surfaceCreated(SurfaceHolder arg0) {
_thread.setRunning(true);
_thread.start();
}
public void surfaceDestroyed(SurfaceHolder arg0) {
boolean retry = true;
_thread.setRunning(false);
while (retry) {
try {
_thread.join();
retry = false;
} catch (InterruptedException e) {
}
}
}
class TutorialThread extends Thread {
private SurfaceHolder _surfaceHolder;
private MySurfaceView _panel;
private boolean _run = false;
public TutorialThread(SurfaceHolder surfaceHolder, MySurfaceView panel) {
_surfaceHolder = surfaceHolder;
_panel = panel;
}
public void setRunning(boolean run) {
_run = run;
}
@Override
public void run() {
Canvas c;
while (_run) {
c = null;
try {
c = _surfaceHolder.lockCanvas(null);
synchronized (_surfaceHolder) {
_panel.draw(c);
}
} finally {
if (c != null) {
_surfaceHolder.unlockCanvasAndPost(c);
}
}
}
}
}
}
*/
| true |
b387e1c193a559b24aa743d592d1ba5bb8e44726 | Java | CaoBing0824/docker_images_test | /src/main/java/com/xy/boot/open/model/params/PubInfoAcceptanceConfirmParam.java | UTF-8 | 337 | 1.71875 | 2 | [] | no_license | package com.xy.boot.open.model.params;
import lombok.Data;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import java.util.List;
@Data
public class PubInfoAcceptanceConfirmParam {
/**
* ๅ
ฌไผๅท้ชๆถ็กฎ่ฎคไฟกๆฏ
*/
@Valid
private List<PubInfoConfirmParam> pubInfoConfirmInfos;
}
| true |
da6b6d6a63dbc53ae2d68c7930ba180729452c15 | Java | Skynet-Jacopo/Freekick | /app/src/main/java/com/football/freekick/beans/JoinMatch.java | UTF-8 | 3,374 | 2.171875 | 2 | [] | no_license | package com.football.freekick.beans;
import com.google.gson.annotations.SerializedName;
/**
* Created by ly on 2017/11/30.
*/
public class JoinMatch {
/**
* join_match : {"id":1,"match_id":1,"join_team_id":2,"cancel_at_by_join":null,"deleted_at":null,
* "created_at":"2017-09-28T10:43:56.000Z","updated_at":"2017-09-28T10:43:56.000Z",
* "status":"confirmation_pending","join_team_color":"ffc300","\u201csize\u201d":"\u201c10\u201d"}
*/
private JoinMatchBean join_match;
public JoinMatchBean getJoin_match() {
return join_match;
}
public void setJoin_match(JoinMatchBean join_match) {
this.join_match = join_match;
}
public static class JoinMatchBean {
/**
* id : 1
* match_id : 1
* join_team_id : 2
* cancel_at_by_join : null
* deleted_at : null
* created_at : 2017-09-28T10:43:56.000Z
* updated_at : 2017-09-28T10:43:56.000Z
* status : confirmation_pending
* join_team_color : ffc300
* โsizeโ : โ10โ
*/
private int id;
private int match_id;
private int join_team_id;
private String cancel_at_by_join;
private String deleted_at;
private String created_at;
private String updated_at;
private String status;
private String join_team_color;
@SerializedName("โsizeโ")
private String _$Size81; // FIXME check this code
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getMatch_id() {
return match_id;
}
public void setMatch_id(int match_id) {
this.match_id = match_id;
}
public int getJoin_team_id() {
return join_team_id;
}
public void setJoin_team_id(int join_team_id) {
this.join_team_id = join_team_id;
}
public String getCancel_at_by_join() {
return cancel_at_by_join;
}
public void setCancel_at_by_join(String cancel_at_by_join) {
this.cancel_at_by_join = cancel_at_by_join;
}
public String getDeleted_at() {
return deleted_at;
}
public void setDeleted_at(String deleted_at) {
this.deleted_at = deleted_at;
}
public String getCreated_at() {
return created_at;
}
public void setCreated_at(String created_at) {
this.created_at = created_at;
}
public String getUpdated_at() {
return updated_at;
}
public void setUpdated_at(String updated_at) {
this.updated_at = updated_at;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getJoin_team_color() {
return join_team_color;
}
public void setJoin_team_color(String join_team_color) {
this.join_team_color = join_team_color;
}
public String get_$Size81() {
return _$Size81;
}
public void set_$Size81(String _$Size81) {
this._$Size81 = _$Size81;
}
}
}
| true |
6de23b6d22226386b7ee83b05e2e2851a4e727b3 | Java | ViniciusMAlves/Show | /Zoologico/src/br/com/vinicius/objeto/Zoologico.java | UTF-8 | 904 | 2.84375 | 3 | [] | 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 br.com.vinicius.objeto;
import java.util.ArrayList;
/**
*
* @author SATC
*/
public class Zoologico {
private int id;
private ArrayList<Animal> animais = new ArrayList<>();
public Zoologico(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public ArrayList<Animal> getAnimais() {
return animais;
}
public void setAnimais(ArrayList<Animal> animais) {
this.animais = animais;
}
@Override
public String toString() {
return "Zoologico" + "\n id=" + id + ",\n animais=" + animais ;
}
}
| true |
13890237ed4cd58d01024955cfcb87e59c59aaa9 | Java | jhmarryme/JavaBasicLearning | /comprehensivePractice/src/main/java/reading/offer/tree/TreeNode.java | UTF-8 | 209 | 2.109375 | 2 | [] | no_license | package reading.offer.tree;
/**
* @author jhmarryme.cn
* @date 2019/9/6 13:28
*/
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
| true |
c31136b4bc049afd79dc1e977477db216ac63645 | Java | qinshijia/BaseProject | /app/src/main/java/com/qinshijia/baseproject/util/LogUtil.java | UTF-8 | 2,792 | 2.71875 | 3 | [] | no_license | package com.qinshijia.baseproject.util;
import android.text.TextUtils;
import android.util.Log;
import io.reactivex.annotations.NonNull;
import io.reactivex.annotations.Nullable;
/**
* ๆฅๅฟ่พๅบๅทฅๅ
ท
*/
public class LogUtil {
public static final boolean SHOW_LOG = true;
private static final int METHOD_OFFSET = 3; //ๆนๆณๅ็งปไฝ็ฝฎ
private static final String TAG = "BASE_PROJECT";
public static void d(String message, Object... args) {
if (SHOW_LOG) {
Log.d(TAG, createMessage(message,args));
}
}
public static void e(@NonNull String message, @Nullable Object... args) {
Log.e(TAG, createMessage(message,args));
}
public static void e(@Nullable Throwable throwable, @NonNull String message, @Nullable Object... args) {
Log.e(TAG, createMessage(message,args));
throwable.printStackTrace();
}
public static void i(@NonNull String message, @Nullable Object... args) {
if (SHOW_LOG) {
Log.i(TAG, createMessage(message,args));
}
}
public static void v(@NonNull String message, @Nullable Object... args) {
if (SHOW_LOG) {
Log.v(TAG, createMessage(message,args));
}
}
public static void w(@NonNull String message, @Nullable Object... args) {
if (SHOW_LOG) {
Log.w(TAG, createMessage(message,args));
}
}
public static void wtf(@NonNull String message, @Nullable Object... args) {
if (SHOW_LOG) {
Log.wtf(TAG, createMessage(message,args));
}
}
//็ๆlogๅ
ๅฎน
private static String createMessage(String message,Object... args) {
String method = getNameFromTrace(METHOD_OFFSET);
StringBuilder sb = new StringBuilder();
if (TextUtils.isEmpty(message)) {
sb.append("NULL");
} else if (args.length > 0) {
String msg = String.format(message, args);
sb.append(msg);
} else {
sb.append(message);
}
sb.append(" ").append(method);
return sb.toString();
}
//่ทๅๆนๆณๅๆๅจๆไปถไฝ็ฝฎ๏ผไปฅไพฟ็นๅปๅฏไปฅ่ทณ่ฝฌ
private static String getNameFromTrace( int place) {
StackTraceElement[] traceElements = new Throwable().getStackTrace();
StringBuilder taskName = new StringBuilder();
if (traceElements != null && traceElements.length > place) {
StackTraceElement traceElement = traceElements[place];
taskName.append("=>");
taskName.append(traceElement.getMethodName());
taskName.append("(").append(traceElement.getFileName()).append(":").append(traceElement.getLineNumber()).append(")");
}
return taskName.toString();
}
}
| true |
44899e3c41255dfa82b3f720498dc79749412f70 | Java | Danka06-beep/work3-2.1 | /company/FromOverduedBookMover.java | UTF-8 | 357 | 2.90625 | 3 | [] | no_license | package company;
public class FromOverduedBookMover extends BookMover{
protected void moveToStatus(Book book, Status requestedStatus) {
if (book.getStatus() == Status.BORROWED) {
book.setStatus(requestedStatus);
System.out.println(String.format("ะะฐะฟัะพั %s, ะพะฑะฐะฑะพัะฐะฝ", book.getStatus()));
}
}
}
| true |
3616ffdf5c6bb1bfc9e073c23b05fdb3f9f330b2 | Java | simundi/spring-multimodules | /sm-repositories/src/main/java/com/simundi/multimodules/repositories/UserRepository.java | UTF-8 | 242 | 1.53125 | 2 | [] | no_license | package com.simundi.multimodules.repositories;
import com.simundi.multimodules.repositories.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Integer> {
}
| true |
00438203733b44bbcdebe59bd027a257bf3cdb60 | Java | LarryGaitanRodriguez/MovieFinderApplicationCSCI | /DBProject/src/ReadDBProperties.java | UTF-8 | 1,494 | 3.171875 | 3 | [] | no_license | import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
//************************************************************************************
// ReadProperties.java Created By: Larry Gaitan-Rodriguez Date: 11/24/2020
// Edited: 11/30/2020
//
// Used to import data from a properties file and return the data using getter methods.
//************************************************************************************
public class ReadDBProperties {
File configFile;
public ReadDBProperties(File file)
{
configFile = file;
}
//Creates the properties Object to read from the dbConfig
private Properties dbProp = new Properties();
//Pulls the configuration data from the properties file.
private void pullDBConfigData() {
try
{
FileInputStream fileInput = new FileInputStream(configFile);
dbProp.load(fileInput);
fileInput.close();
}
catch(FileNotFoundException fileE)
{
fileE.printStackTrace();
}
catch(IOException IOE)
{
IOE.printStackTrace();
}
}
//Following methods return property values
public String getURL()
{
pullDBConfigData();
return dbProp.getProperty("url");
}
public String getUsername()
{
pullDBConfigData();
return dbProp.getProperty("username");
}
public String getPassword()
{
pullDBConfigData();
return dbProp.getProperty("password");
}
}
| true |
c86d720d1bb685c2b3e3292a82dfccae18c3961e | Java | ns-bruno/SAVARE | /app/src/main/java/com/savare/funcoes/rotinas/ImportarDadosTxtRotinas.java | UTF-8 | 127,735 | 1.601563 | 2 | [] | no_license | package com.savare.funcoes.rotinas;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.sql.Blob;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Locale;
import java.util.Scanner;
import android.app.Activity;
import android.app.Notification;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.media.RingtoneManager;
import android.util.Log;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.TextView;
import com.savare.R;
import com.savare.banco.funcoesSql.AreasSql;
import com.savare.banco.funcoesSql.CartaoSql;
import com.savare.banco.funcoesSql.CidadeSql;
import com.savare.banco.funcoesSql.ClasseSql;
import com.savare.banco.funcoesSql.CobrancaSql;
import com.savare.banco.funcoesSql.EmbalagemSql;
import com.savare.banco.funcoesSql.EmpresaSql;
import com.savare.banco.funcoesSql.EnderecoSql;
import com.savare.banco.funcoesSql.EstadoSql;
import com.savare.banco.funcoesSql.EstoqueSql;
import com.savare.banco.funcoesSql.FotosSql;
import com.savare.banco.funcoesSql.GradeSql;
import com.savare.banco.funcoesSql.ItemOrcamentoSql;
import com.savare.banco.funcoesSql.LocacaoSql;
import com.savare.banco.funcoesSql.MarcaSql;
import com.savare.banco.funcoesSql.OrcamentoSql;
import com.savare.banco.funcoesSql.ParametrosSql;
import com.savare.banco.funcoesSql.ParcelaSql;
import com.savare.banco.funcoesSql.PercentualSql;
import com.savare.banco.funcoesSql.PessoaSql;
import com.savare.banco.funcoesSql.PlanoPagamentoSql;
import com.savare.banco.funcoesSql.PortadorBancoSql;
import com.savare.banco.funcoesSql.ProdutoLojaSql;
import com.savare.banco.funcoesSql.ProdutoRecomendadoSql;
import com.savare.banco.funcoesSql.ProdutoSql;
import com.savare.banco.funcoesSql.ProfissaoSql;
import com.savare.banco.funcoesSql.RamoAtividadeSql;
import com.savare.banco.funcoesSql.SituacaoTributariaSql;
import com.savare.banco.funcoesSql.StatusSql;
import com.savare.banco.funcoesSql.TipoClienteSql;
import com.savare.banco.funcoesSql.TipoDocumentoSql;
import com.savare.banco.funcoesSql.UnidadeVendaSql;
import com.savare.banco.funcoesSql.UsuarioSQL;
import com.savare.configuracao.ConfiguracoesInternas;
import com.savare.funcoes.FuncoesPersonalizadas;
import br.com.goncalves.pugnotification.notification.Load;
import br.com.goncalves.pugnotification.notification.PugNotification;
public class ImportarDadosTxtRotinas {
private Context context;
private String localDados = "",
mensagem = " ";
private int telaChamou = -1;
private String TAG = "SAVARE";
public static final String BLOCO_S = "BLOCO_S",
BLOCO_C = "BLOCO_C",
BLOCO_A = "BLOCO_A",
BLOCO_R = "BLOCO_R",
BLOCO_COMPLETO = "BLOCO_COMPLETO";
public static final String[] BLOCOS = {BLOCO_S, BLOCO_C, BLOCO_A, BLOCO_R, BLOCO_COMPLETO};
public static final String BLOCO_S100_SMAEMPRE = "S100",
BLOCO_C200_CFAAREAS = "C200",
BLOCO_C201_CFAATIVI = "C201",
BLOCO_C202_CFASTATU = "C202",
BLOCO_C203_CFATPDOC = "C203",
BLOCO_C204_CFACCRED = "C204",
BLOCO_C205_CFAPORTA = "C205",
BLOCO_C206_CFAPROFI = "C206",
BLOCO_C207_CFATPCLI = "C207",
BLOCO_C208_CFATPCOB = "C208",
BLOCO_C209_CFAESTAD = "C209",
BLOCO_C210_CFACIDAD = "C210",
BLOCO_C211_CFACLIFO = "C211",
BLOCO_C212_CFAENDER = "C212",
BLOCO_C213_CFAPARAM = "C213",
BLOCO_C214_CFAFOTOS = "C214",
BLOCO_A300_AEAPLPGT = "A300",
BLOCO_A301_AEACLASE = "A301",
BLOCO_A302_AEAUNVEN = "A302",
BLOCO_A303_AEAGRADE = "A303",
BLOCO_A304_AEAMARCA = "A304",
BLOCO_A305_AEACODST = "A305",
BLOCO_A306_AEAPRODU = "A306",
BLOCO_A307_AEAEMBAL = "A307",
BLOCO_A308_AEAPLOJA = "A308",
BLOCO_A309_AEALOCES = "A309",
BLOCO_A310_AEAESTOQ = "A310",
BLOCO_A311_AEAORCAM = "A311",
BLOCO_A312_AEAITORC = "A312",
BLOCO_A313_AEAPERCE = "A313",
BLOCO_A314_AEAPRREC = "A314",
BLOCO_R400_RPAPARCE = "R400";
public static final String LAYOUT = "001";
private boolean layoutValido = false;
private ProgressBar progressRecebimentoDados;
private TextView textMensagemProcesso;
public static final int TELA_RECEPTOR_ALARME = 0;
public ImportarDadosTxtRotinas(Context context, String localDados) {
this.context = context;
this.localDados = localDados;
}
public ImportarDadosTxtRotinas(Context context, String localDados, int telaChamou) {
this.context = context;
this.localDados = localDados;
this.telaChamou = telaChamou;
}
public ImportarDadosTxtRotinas(Context context, String localDados, ProgressBar progressBar, TextView textMensagem) {
this.context = context;
this.localDados = localDados;
this.progressRecebimentoDados = progressBar;
this.textMensagemProcesso = textMensagem;
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
progressRecebimentoDados.setVisibility(View.VISIBLE);
progressRecebimentoDados.setIndeterminate(true);
textMensagemProcesso.setText("Validando os dados...");
}
});
}
public void importarDados(){
Log.i(TAG, "Executando a rotina importarDados - ImportarDadosTxtRotinas");
// Cria uma notificacao para ser manipulado
Load mLoad = PugNotification.with(context).load()
.identifier(ConfiguracoesInternas.IDENTIFICACAO_NOTIFICACAO)
.smallIcon(R.mipmap.ic_launcher)
.largeIcon(R.mipmap.ic_launcher)
.title(R.string.importar_dados_recebidos)
.message("Importando os dados, aguarde...")
.flags(Notification.DEFAULT_SOUND);
final FuncoesPersonalizadas funcoes = new FuncoesPersonalizadas(context);
try {
// Pego o arquivo txt e insiro um delimitador
Scanner scannerDados = new Scanner(new FileReader(localDados)).useDelimiter("\\||\\n");
int totalLinha = 0;
//Indicamos o arquivo que sera lido
FileReader fileReader = new FileReader(localDados);
//Criamos o objeto bufferReader que nos oferece o metodo de leitura readLine()
BufferedReader bufferedReader = new BufferedReader(fileReader);
//Fazemos um loop linha a linha no arquivo, enquanto ele seja diferente de null.
//O metodo readLine() devolve a linha na posicao do loop para a variavel linha.
while ( (bufferedReader.readLine() ) != null) {
//Aqui imprimimos a linha
//System.out.println(linha);
totalLinha++;
}
//liberamos o fluxo dos objetos ou fechamos o arquivo
fileReader.close();
bufferedReader.close();
final int finalTotalLinha = totalLinha;
// Indica que essa notificacao eh do tipo progress
mLoad.progress().value(0, totalLinha, false).build();
if (progressRecebimentoDados != null) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Torna a barra de progresso finita
progressRecebimentoDados.setIndeterminate(false);
// Zera a contagem do progresso
progressRecebimentoDados.setProgress(0);
// Inseri o total que a barra de progresso pode ir
progressRecebimentoDados.setMax(finalTotalLinha);
}
});
}
int incremento = 0;
// Passa por todas as linha do arquivo txt
while(scannerDados.hasNextLine()){
Log.i(TAG, "Escaneando as linhas(sccanerDados) - " + incremento + " - ImportarDadosTxtRotinas");
final int finalIncremento = incremento;
if (progressRecebimentoDados != null) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Incrementa o progresso
progressRecebimentoDados.setProgress(finalIncremento);
}
});
}
// Incrementa o numero de linha scaneadas
incremento ++;
// Pega a posicao da linha atual
final int posicaoLinhaAtual = incremento;
final int totalLinhaRegistro = totalLinha;
// Pega apenas uma linha
Scanner scannerLinha = new Scanner(scannerDados.nextLine()).useDelimiter("\\|");
// Pega o primeiro token da linha
String registro = scannerLinha.next();
mLoad.message(posicaoLinhaAtual + " de " + totalLinhaRegistro + " Importando o registro " + registro);
mLoad.progress().value(posicaoLinhaAtual, totalLinhaRegistro, false).build();
// Checa se o registro pertence ao bloco 0000
if(registro.equalsIgnoreCase("0000")){
// Pega a linha completa
String linha = scannerLinha.nextLine();
// Checa se o layou esta valido
layoutValido = checaLayout(linha);
if(layoutValido){
// Atualiza a mensagem na notificacao
mLoad.message("Layout Validado com sucesso.").progress().build();
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText("Layout Validado com sucesso.");
}
});
}
}else{
mLoad.message("Layout Invalidado.").progress().build();
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText("Layout Invรกlido.");
}
});
}
mensagem += "Layout Invรกlido";
}
} else if(registro.equalsIgnoreCase(BLOCO_S100_SMAEMPRE) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_S100_SMAEMPRE + linha);
}
});
}
importarRegistroEmpresa(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C200_CFAAREAS) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C200_CFAAREAS + linha);
}
});
}
importarRegistroAreas(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C201_CFAATIVI) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C201_CFAATIVI + linha);
}
});
}
importarRegistroAtividade(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C202_CFASTATU) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" mportando o bloco " + BLOCO_C202_CFASTATU + linha);
}
});
}
importarRegistroStatus(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C203_CFATPDOC) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C203_CFATPDOC + linha);
}
});
}
importarRegistroTipoDocumento(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C204_CFACCRED) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C204_CFACCRED + linha);
}
});
}
importarRegistroCartaoCredito(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C205_CFAPORTA) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C205_CFAPORTA + linha);
}
});
}
importarRegistroPortador(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C206_CFAPROFI) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C206_CFAPROFI + linha);
}
});
}
importarRegistroProfissao(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C207_CFATPCLI) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C207_CFATPCLI + linha);
}
});
}
importarRegistroTipoCliente(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C208_CFATPCOB) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C208_CFATPCOB + linha);
}
});
}
importarRegistroTipoCobranca(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C209_CFAESTAD) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C209_CFAESTAD + linha);
}
});
}
importarRegistroEstado(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C210_CFACIDAD) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C210_CFACIDAD + linha);
}
});
}
importarRegistroCidade(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C211_CFACLIFO) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C211_CFACLIFO + linha);
}
});
}
importarRegistroPessoa(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C212_CFAENDER) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C212_CFAENDER + linha);
}
});
}
importarRegistroEndereco(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C213_CFAPARAM) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C213_CFAPARAM + linha);
}
});
}
importarRegistroParametro(linha);
} else if(registro.equalsIgnoreCase(BLOCO_C214_CFAFOTOS) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_C214_CFAFOTOS + linha);
}
});
}
importarRegistroFotos(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A300_AEAPLPGT) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A300_AEAPLPGT + linha);
}
});
}
importarRegistroPlanoPgto(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A301_AEACLASE) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A301_AEACLASE + linha);
}
});
}
importarRegistroClasse(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A302_AEAUNVEN) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A302_AEAUNVEN + linha);
}
});
}
importarRegistroUnidadeVenda(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A303_AEAGRADE) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A303_AEAGRADE + linha);
}
});
}
importarRegistroGrade(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A304_AEAMARCA) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A304_AEAMARCA + linha);
}
});
}
importarRegistroMarca(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A305_AEACODST) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A305_AEACODST + linha);
}
});
}
importarRegistroSituacaoTributaria(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A306_AEAPRODU) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A306_AEAPRODU + linha);
}
});
}
importarRegistroProduto(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A307_AEAEMBAL) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A307_AEAEMBAL + linha);
}
});
}
importarRegistroEmbalagem(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A308_AEAPLOJA) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A308_AEAPLOJA + linha);
}
});
}
importarRegistroPLoja(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A309_AEALOCES) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A309_AEALOCES + linha);
}
});
}
importarRegistroLocacao(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A310_AEAESTOQ) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A310_AEAESTOQ + linha);
}
});
}
importarRegistroEstoque(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A311_AEAORCAM) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A311_AEAORCAM + linha);
}
});
}
importarRegistroOrcamento(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A312_AEAITORC) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A312_AEAITORC + linha);
}
});
}
importarRegistroItemOrcamento(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A313_AEAPERCE) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A313_AEAPERCE + linha);
}
});
}
importarRegistroPercentual(linha);
} else if(registro.equalsIgnoreCase(BLOCO_A314_AEAPRREC) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_A313_AEAPERCE + linha);
}
});
}
importarRegistroProdutoRecomendado(linha);
} else if(registro.equalsIgnoreCase(BLOCO_R400_RPAPARCE) && layoutValido){
// Pega a linha completa
final String linha = scannerLinha.nextLine();
Log.i(TAG, linha + " - ImportarDadosTxtRotinas");
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText(posicaoLinhaAtual + " de " + totalLinhaRegistro +" Importando o bloco " + BLOCO_R400_RPAPARCE + linha);
}
});
}
importarRegistroParcela(linha);
}
} // Fim while
// Pega o tempo atual em milesegundos
//long tempoFinal = System.currentTimeMillis();
//SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MMM-dd HH:mm:ss", Locale.ENGLISH);
//final int tempoCorridoMin = Integer.parseInt(funcoes.diferencaEntreDataHora(FuncoesPersonalizadas.MINUTOS, sdf.format(tempoInicial), sdf.format(tempoFinal)));
//final int tempoCorridoSeg = (Integer.parseInt(funcoes.diferencaEntreDataHora(FuncoesPersonalizadas.SEGUNDOS, sdf.format(tempoInicial), sdf.format(tempoFinal)))) - (60 * tempoCorridoMin);
// Fecha os dados do arquivo
scannerDados.close();
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Coloca a barra de progresso em modo invisivel e sem ocupar o seu proprio espaco
progressRecebimentoDados.setVisibility(View.INVISIBLE);
}
});
}
if(incremento == totalLinha){
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText("Recebemos todos os registros");
//textMensagemProcesso.setText("Recebemos todos os registros em " + tempoCorridoMin + " Min. e " + tempoCorridoSeg + " Seg.");
}
});
}
mensagem += "Recebemos todos os registros.(" + totalLinha + ") \n";
} else {
final int totalLinha2 = totalLinha;
final int incremento2 = incremento;
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
// Atualiza o texto da tela de sincronizacao
textMensagemProcesso.setText("Nรฃo foi recebido todos os registros. Diferenรงa de " + (totalLinha2 - incremento2));
//"\n Recebemos em " + tempoCorridoMin + " Min. e " + tempoCorridoSeg + " Seg.");
}
});
}
mensagem += "Nรฃo foi recebido todos os registros. \n Diferenรงa de " + (totalLinha2 - incremento2); // + "\n Recebemos em " + tempoCorridoMin + " Min. e " + tempoCorridoSeg + " Seg.";
}
// Marca a aplicacao que nao esta mais recebendo dados
funcoes.setValorXml("RecebendoDados", "N");
} catch (final Exception e) {
Log.e(TAG, "erro, Nรฃo foi possรญvel escanear os dados do arquivo. " + e.getMessage() + " - ImportarDadosTxtRotinas");
funcoes.setValorXml("RecebendoDados", "N");
mensagem += "Nรฃo foi possรญvel escanear os dados do arquivo. \n" + e.getMessage();
// Atualiza a mensagem na notificacao
mLoad.bigTextStyle(mensagem, e.getMessage()).simple().build();
if(telaChamou != TELA_RECEPTOR_ALARME){
final ContentValues dadosMensagem = new ContentValues();
dadosMensagem.put("comando", 0);
dadosMensagem.put("tela", "ReceberDadosFtpAsyncRotinas");
dadosMensagem.put("mensagem", "Nรฃo foi possรญvel escanear os dados do arquivo. \n" + e.getMessage());
dadosMensagem.put("dados", e.toString());
dadosMensagem.put("usuario", funcoes.getValorXml("Usuario"));
dadosMensagem.put("empresa", funcoes.getValorXml("Empresa"));
dadosMensagem.put("email", funcoes.getValorXml("Email"));
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
progressRecebimentoDados.setVisibility(View.INVISIBLE);
textMensagemProcesso.setText(mensagem + "\n" + e.getMessage());
funcoes.menssagem(dadosMensagem);
}
});
}
} /*catch (final FileNotFoundException e) {
mensagem += "Nรฃo foi possรญvel escanear os dados do arquivo. \n" + e.getMessage() + "\n";
if(telaChamou != TELA_RECEPTOR_ALARME){
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
progressRecebimentoDados.setVisibility(View.INVISIBLE);
textMensagemProcesso.setText(mensagem + "\n" + e.getMessage());
ContentValues dadosMensagem = new ContentValues();
FuncoesPersonalizadas funcoes = new FuncoesPersonalizadas(context);
dadosMensagem.put("comando", 0);
dadosMensagem.put("tela", "ReceberDadosFtpAsyncRotinas");
dadosMensagem.put("mensagem", mensagem);
dadosMensagem.put("dados", e.toString());
dadosMensagem.put("usuario", funcoes.getValorXml("Usuario"));
dadosMensagem.put("empresa", funcoes.getValorXml("Empresa"));
dadosMensagem.put("email", funcoes.getValorXml("Email"));
funcoes.menssagem(dadosMensagem);
}
});
}
}*/
// Checa se que esta chamando esta classe eh o alarme
if( (mensagem != null) && (mensagem.length() > 2) ){
// Cria uma notificacao para ser manipulado
mLoad = PugNotification.with(context)
.load()
.identifier(ConfiguracoesInternas.IDENTIFICACAO_NOTIFICACAO)
.smallIcon(R.mipmap.ic_launcher)
.largeIcon(R.mipmap.ic_launcher)
.title(R.string.importar_dados_recebidos)
.bigTextStyle(mensagem)
.flags(Notification.DEFAULT_SOUND);
mLoad.simple().build();
}
} // Fim importarDados
private boolean checaLayout(String linha){
boolean valido = false;
Scanner scannerLayout = new Scanner(linha).useDelimiter("\\|");
if(scannerLayout.next().equalsIgnoreCase(LAYOUT)){
valido = true;
}
return valido;
}
private void importarRegistroEmpresa(String linha){
Scanner scannerEmpresa = new Scanner(linha).useDelimiter("\\|");
final String FINALIDADE = scannerEmpresa.next();
final String idEmpre = scannerEmpresa.next();
String dtAlt = scannerEmpresa.next();
String nomeRazao = scannerEmpresa.next();
String nomeFantasia = scannerEmpresa.next();
String cpfCgc = scannerEmpresa.next();
String orcSemEstoque = scannerEmpresa.next();
String diasAtrazo = scannerEmpresa.next();
String semMovimento = scannerEmpresa.next();
String jurosDiario = scannerEmpresa.next();
String vendeBloqueadoOrc = scannerEmpresa.next();
String vendeBloqueadoPed = scannerEmpresa.next();
String validadeFicha = scannerEmpresa.next();
String vlMinPrazoVarejo = scannerEmpresa.next();
String vlMinPrazoAtacado = scannerEmpresa.next();
String vlMinVistaVarejo = scannerEmpresa.next();
String vlMinVistaAtacado = scannerEmpresa.next();
String multiplosPlanos = scannerEmpresa.next();
String diaDestacaProduto = scannerEmpresa.next();
String fechaVendaCredNegAtacado = scannerEmpresa.next();
String fechaVendaCredNegVarejo = scannerEmpresa.next();
String tipoAcumuloCreditoAtacado = scannerEmpresa.next();
String tipoAcumuloCreditoVarejo = scannerEmpresa.next();
String periodoCreditoAtacado = scannerEmpresa.next();
String periodoCreditoVarejo = scannerEmpresa.next();
scannerEmpresa = null;
// Cria variavel para salvar os dados da empresa e enviar para o banco de dados
final ContentValues dadosEmpresa = new ContentValues();
// Inseri os valores
dadosEmpresa.put("ID_SMAEMPRE", idEmpre);
dadosEmpresa.put("DT_ALT", dtAlt);
dadosEmpresa.put("NOME_RAZAO", nomeRazao);
dadosEmpresa.put("NOME_FANTASIA", nomeFantasia);
dadosEmpresa.put("CPF_CGC", cpfCgc);
dadosEmpresa.put("ORC_SEM_ESTOQUE", orcSemEstoque);
dadosEmpresa.put("DIAS_ATRAZO", diasAtrazo);
dadosEmpresa.put("SEM_MOVIMENTO", semMovimento);
dadosEmpresa.put("JUROS_DIARIO", jurosDiario);
dadosEmpresa.put("VENDE_BLOQUEADO_ORC", vendeBloqueadoOrc);
dadosEmpresa.put("VENDE_BLOQUEADO_PED", vendeBloqueadoPed);
dadosEmpresa.put("VALIDADE_FICHA_CLIENTE", validadeFicha);
dadosEmpresa.put("VL_MIN_PRAZO_VAREJO", vlMinPrazoVarejo);
dadosEmpresa.put("VL_MIN_PRAZO_ATACADO", vlMinPrazoAtacado);
dadosEmpresa.put("VL_MIN_VISTA_VAREJO", vlMinVistaVarejo);
dadosEmpresa.put("VL_MIN_VISTA_ATACADO", vlMinVistaAtacado);
dadosEmpresa.put("MULTIPLOS_PLANOS", multiplosPlanos);
dadosEmpresa.put("QTD_DIAS_DESTACA_PRODUTO", diaDestacaProduto);
dadosEmpresa.put("FECHA_VENDA_CREDITO_NEGATIVO_ATACADO", fechaVendaCredNegAtacado);
dadosEmpresa.put("FECHA_VENDA_CREDITO_NEGATIVO_VAREJO", fechaVendaCredNegVarejo);
dadosEmpresa.put("TIPO_ACUMULO_CREDITO_ATACADO", tipoAcumuloCreditoAtacado);
dadosEmpresa.put("TIPO_ACUMULO_CREDITO_VAREJO", tipoAcumuloCreditoVarejo);
dadosEmpresa.put("PERIODO_CREDITO_ATACADO", periodoCreditoAtacado);
dadosEmpresa.put("PERIODO_CREDITO_VAREJO", periodoCreditoVarejo);
final EmpresaSql empresaSql = new EmpresaSql(context);
// Pega o sql para passar para o statement
final String sql = empresaSql.construirSqlStatement(dadosEmpresa);
// Pega o argumento para o statement
final String[] argumentoSql = empresaSql.argumentoStatement(dadosEmpresa);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//empresaSql.insertOrReplace(dadosEmpresa);
empresaSql.insertOrReplaceFast(sql, argumentoSql);
}
});
}else {
empresaSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
empresaSql.update(dadosEmpresa, "ID_SMAEMPRE = " + idEmpre);
}
});
}else {
empresaSql.update(dadosEmpresa, "ID_SMAEMPRE = " + idEmpre);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
empresaSql.delete("ID_SMAEMPRE = " + idEmpre);
}
});
}else {
empresaSql.delete("ID_SMAEMPRE = " + idEmpre);
}
}
//dadosEmpresa.clear();
} // Fim importarRegistroEmpresa
private void importarRegistroPessoa(String linha){
Scanner scannerPessoa = new Scanner(linha).useDelimiter("\\|");
final String FINALIDADE = scannerPessoa.next();
final String idClifo = scannerPessoa.next();
String idProfi = scannerPessoa.next();
String idAtivi = scannerPessoa.next();
String idAreas = scannerPessoa.next();
String idTpCli = scannerPessoa.next();
String idStatu = scannerPessoa.next();
String idCCred = scannerPessoa.next();
String idEmpre = scannerPessoa.next();
String dtAlt = scannerPessoa.next();
String cpfCnpj = scannerPessoa.next();
String ieRg = scannerPessoa.next();
String nomeRazao = scannerPessoa.next();
String nomeFantasia = scannerPessoa.next();
String dtNascimento = scannerPessoa.next();
String codigoCli = scannerPessoa.next();
String codigoFun = scannerPessoa.next();
String codigoUsu = scannerPessoa.next();
String codigoTra = scannerPessoa.next();
String cliente = scannerPessoa.next();
String funcionario = scannerPessoa.next();
String usuario = scannerPessoa.next();
String transportadora = scannerPessoa.next();
String sexo = scannerPessoa.next();
String inscJunta = scannerPessoa.next();
String inscSuframa = scannerPessoa.next();
String inscMunicipal = scannerPessoa.next();
String inscProdutor = scannerPessoa.next();
String rendaMesGiro = scannerPessoa.next();
String capitalSocial = scannerPessoa.next();
String estoqueMercadorias = scannerPessoa.next();
String estoqueMateriaPrima = scannerPessoa.next();
String movtoVenda = scannerPessoa.next();
String despesas = scannerPessoa.next();
String empresaTrabalha = scannerPessoa.next();
String obs = scannerPessoa.next();
String pessoa = scannerPessoa.next();
String civil = scannerPessoa.next();
String conjuge = scannerPessoa.next();
String cpfConjuge = scannerPessoa.next();
String dtNascimentoConjuge = scannerPessoa.next();
String qtdeFuncionarios = scannerPessoa.next();
String outrasRendas = scannerPessoa.next();
String numeroDependenteMaior = scannerPessoa.next();
String numeroDependenteMenor = scannerPessoa.next();
String complementoCargoConjuge = scannerPessoa.next();
String rgConjuge = scannerPessoa.next();
String orgaoEmissorConjuge = scannerPessoa.next();
String limiteConjuge = scannerPessoa.next();
String empresaConjuge = scannerPessoa.next();
String admissaoConjuge = scannerPessoa.next();
String rendaConjuge = scannerPessoa.next();
String ativo = scannerPessoa.next();
String enviarExtrato = scannerPessoa.next();
String tipoExtrato = scannerPessoa.next();
String conjugePodeComprar = scannerPessoa.next();
String dtUltimaCompra = scannerPessoa.next();
String dtRenovacao = scannerPessoa.next();
// Elimina a memoria da variavel
scannerPessoa = null;
// Cria variavel para salvar os dados da empresa e enviar para o banco de dados
final ContentValues dadosPessoa = new ContentValues();
// Inseri os valores
dadosPessoa.put("ID_CFACLIFO", idClifo);
dadosPessoa.put("ID_CFAPROFI", idProfi);
dadosPessoa.put("ID_CFAATIVI", idAtivi);
dadosPessoa.put("ID_CFAAREAS", idAreas);
dadosPessoa.put("ID_CFATPCLI", idTpCli);
dadosPessoa.put("ID_CFASTATU", idStatu);
dadosPessoa.put("ID_CFACCRED", idCCred);
dadosPessoa.put("ID_SMAEMPRE", idEmpre);
dadosPessoa.put("DT_ALT", dtAlt);
dadosPessoa.put("CPF_CNPJ", cpfCnpj);
dadosPessoa.put("IE_RG", ieRg);
dadosPessoa.put("NOME_RAZAO", nomeRazao.replace("'", " "));
dadosPessoa.put("NOME_FANTASIA", nomeFantasia.replace(",", " "));
dadosPessoa.put("DT_NASCIMENTO", dtNascimento.replace("0000-00-00", ""));
dadosPessoa.put("CODIGO_CLI", codigoCli);
dadosPessoa.put("CODIGO_FUN", codigoFun);
dadosPessoa.put("CODIGO_USU", codigoUsu);
dadosPessoa.put("CODIGO_TRA", codigoTra);
dadosPessoa.put("CLIENTE", cliente);
dadosPessoa.put("FUNCIONARIO", funcionario);
dadosPessoa.put("USUARIO", usuario);
dadosPessoa.put("TRANSPORTADORA", transportadora);
dadosPessoa.put("SEXO", sexo);
dadosPessoa.put("INSC_JUNTA", inscJunta);
dadosPessoa.put("INSC_SUFRAMA", inscSuframa);
dadosPessoa.put("INSC_MUNICIPAL", inscMunicipal);
dadosPessoa.put("INSC_PRODUTOR", inscProdutor);
dadosPessoa.put("RENDA_MES_GIRO", rendaMesGiro);
dadosPessoa.put("CAPITAL_SOCIAL", capitalSocial);
dadosPessoa.put("EST_MERCADORIAS", estoqueMercadorias);
dadosPessoa.put("EST_MAT_PRIMA", estoqueMateriaPrima);
dadosPessoa.put("MOVTO_VENDAS", movtoVenda);
dadosPessoa.put("DESPESAS", despesas);
dadosPessoa.put("EMPRESA_TRAB", empresaTrabalha);
dadosPessoa.put("OBS", obs);
dadosPessoa.put("PESSOA", pessoa);
dadosPessoa.put("CIVIL", civil);
dadosPessoa.put("CONJUGE", conjuge);
dadosPessoa.put("CPF_CONJUGE", cpfConjuge);
dadosPessoa.put("DT_NASC_CONJ", dtNascimentoConjuge.replace("0000-00-00", ""));
dadosPessoa.put("QTDE_FUNCIONARIOS", qtdeFuncionarios);
dadosPessoa.put("OUTRAS_RENDAS", outrasRendas);
dadosPessoa.put("NUM_DEP_MAIOR", numeroDependenteMaior);
dadosPessoa.put("NUM_DEP_MENOR", numeroDependenteMenor);
dadosPessoa.put("COMPLEMENTO_CARGO_CONJ", complementoCargoConjuge);
dadosPessoa.put("RG_CONJUGE", rgConjuge);
dadosPessoa.put("ORGAO_EMISSOR_CONJ", orgaoEmissorConjuge);
dadosPessoa.put("LIMITE_CONJUGE", limiteConjuge);
dadosPessoa.put("EMPRESA_CONJUGE", empresaConjuge);
dadosPessoa.put("ADMISSAO_CONJUGE", admissaoConjuge);
dadosPessoa.put("RENDA_CONJUGE", rendaConjuge);
dadosPessoa.put("ATIVO", ativo);
dadosPessoa.put("ENVIAR_EXTRATO", enviarExtrato);
dadosPessoa.put("TIPO_EXTRATO", tipoExtrato);
dadosPessoa.put("CONJ_PODE_COMPRAR", conjugePodeComprar);
dadosPessoa.put("DT_ULT_COMPRA", dtUltimaCompra.replace("0000-00-00", ""));
dadosPessoa.put("DT_RENOVACAO", dtRenovacao.replace("0000-00-00", ""));
dadosPessoa.put("STATUS_CADASTRO_NOVO", "null");
final PessoaSql pessoaSql = new PessoaSql(context);
// Pega o sql para passar para o statement
final String sql = pessoaSql.construirSqlStatement(dadosPessoa);
// Pega o argumento para o statement
final String[] argumentoSql = pessoaSql.argumentoStatement(dadosPessoa);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//pessoaSql.insertOrReplace(dadosPessoa);
pessoaSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
pessoaSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
pessoaSql.update(dadosPessoa, "ID_CFACLIFO = " + idClifo);
}
});
} else {
pessoaSql.update(dadosPessoa, "ID_CFACLIFO = " + idClifo);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
pessoaSql.delete("ID_CFACLIFO = " + idClifo);
}
});
} else {
pessoaSql.delete("ID_CFACLIFO = " + idClifo);
}
}
//dadosPessoa.clear();
} // Pessoa
private void importarRegistroAreas(String linha){
Scanner scannerAreas = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerAreas.next();
final String idAreas = scannerAreas.next();
String dtAlt = scannerAreas.next();
String codigo = scannerAreas.next();
String descricao = scannerAreas.next();
String descAtacVista = scannerAreas.next();
String descAtacPrazo = scannerAreas.next();
String descVareVista = scannerAreas.next();
String descVarePrazo = scannerAreas.next();
String descPromocao = scannerAreas.next();
// Libera memoria
scannerAreas = null;
final ContentValues dadosAreas = new ContentValues();
dadosAreas.put("ID_CFAAREAS", idAreas);
dadosAreas.put("DT_ALT", dtAlt);
dadosAreas.put("CODIGO", codigo);
dadosAreas.put("DESCRICAO", descricao);
dadosAreas.put("DESC_ATAC_VISTA", descAtacVista);
dadosAreas.put("DESC_ATAC_PRAZO", descAtacPrazo);
dadosAreas.put("DESC_VARE_VISTA", descVareVista);
dadosAreas.put("DESC_VARE_PRAZO", descVarePrazo);
dadosAreas.put("DESC_PROMOCAO", descPromocao);
final AreasSql areasSql = new AreasSql(context);
// Pega o sql para passar para o statement
final String sql = areasSql.construirSqlStatement(dadosAreas);
// Pega o argumento para o statement
final String[] argumentoSql = areasSql.argumentoStatement(dadosAreas);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//areasSql.insertOrReplace(dadosAreas);
areasSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
areasSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
areasSql.update(dadosAreas, "ID_CFAAREAS = " + idAreas);
}
});
} else {
areasSql.update(dadosAreas, "ID_CFAAREAS = " + idAreas);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
areasSql.delete("ID_CFAAREAS = " + idAreas);
}
});
} else {
areasSql.delete("ID_CFAAREAS = " + idAreas);
}
}
//dadosAreas.clear();
} // FIm Areas
private void importarRegistroAtividade(String linha){
Scanner scannerAtividade = new Scanner(linha).useDelimiter("\\|");
final String FINALIDADE = scannerAtividade.next();
final String idAtivi = scannerAtividade.next();
String dtAlt = scannerAtividade.next();
String codigo = scannerAtividade.next();
String descricao = scannerAtividade.next();
String descAtacVista = scannerAtividade.next();
String descAtacPrazo = scannerAtividade.next();
String descVareVista = scannerAtividade.next();
String descVarePrazo = scannerAtividade.next();
String descPromocao = scannerAtividade.next();
// Libera a memoria da variavel
scannerAtividade = null;
final ContentValues dadosAtividade = new ContentValues();
dadosAtividade.put("ID_CFAATIVI", idAtivi);
dadosAtividade.put("DT_ALT", dtAlt);
dadosAtividade.put("CODIGO", codigo);
dadosAtividade.put("DESCRICAO", descricao);
dadosAtividade.put("DESC_ATAC_VISTA", descAtacVista);
dadosAtividade.put("DESC_ATAC_PRAZO", descAtacPrazo);
dadosAtividade.put("DESC_VARE_VISTA", descVareVista);
dadosAtividade.put("DESC_VARE_PRAZO", descVarePrazo);
dadosAtividade.put("DESC_PROMOCAO", descPromocao);
final RamoAtividadeSql atividadeSql = new RamoAtividadeSql(context);
// Pega o sql para passar para o statement
final String sql = atividadeSql.construirSqlStatement(dadosAtividade);
// Pega o argumento para o statement
final String[] argumentoSql = atividadeSql.argumentoStatement(dadosAtividade);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//atividadeSql.insertOrReplace(dadosAtividade);
atividadeSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
atividadeSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
atividadeSql.update(dadosAtividade, "ID_CFAATIVI = " + idAtivi);
}
});
} else {
atividadeSql.update(dadosAtividade, "ID_CFAATIVI = " + idAtivi);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
atividadeSql.delete("ID_CFAATIVI = " + idAtivi);
}
});
} else {
atividadeSql.delete("ID_CFAATIVI = " + idAtivi);
}
}
//dadosAtividade.clear();
} // Fim atividade
private void importarRegistroStatus(String linha){
Scanner scannerAtividade = new Scanner(linha).useDelimiter("\\|");
final String FINALIDADE = scannerAtividade.next();
final String idStatu = scannerAtividade.next();
String dtAlt = scannerAtividade.next();
String codigo = scannerAtividade.next();
String descricao = scannerAtividade.next();
String mensagem = scannerAtividade.next();
String bloqueia = scannerAtividade.next();
String descAtacVista = scannerAtividade.next();
String descAtacPrazo = scannerAtividade.next();
String descVareVista = scannerAtividade.next();
String descVarePrazo = scannerAtividade.next();
String descPromocao = scannerAtividade.next();
String parcelaEmAberto = scannerAtividade.next();
String vistaPrazo = scannerAtividade.next();
scannerAtividade = null;
final ContentValues dadosStatus = new ContentValues();
dadosStatus.put("ID_CFASTATU", idStatu);
dadosStatus.put("DT_ALT", dtAlt);
dadosStatus.put("CODIGO", codigo);
dadosStatus.put("DESCRICAO", descricao);
dadosStatus.put("MENSAGEM", mensagem);
dadosStatus.put("BLOQUEIA", bloqueia);
dadosStatus.put("DESC_ATAC_VISTA", descAtacVista);
dadosStatus.put("DESC_ATAC_PRAZO", descAtacPrazo);
dadosStatus.put("DESC_VARE_VISTA", descVareVista);
dadosStatus.put("DESC_VARE_PRAZO", descVarePrazo);
dadosStatus.put("DESC_PROMOCAO", descPromocao);
dadosStatus.put("PARCELA_EM_ABERTO", parcelaEmAberto);
dadosStatus.put("VISTA_PRAZO", vistaPrazo);
final StatusSql statusSql = new StatusSql(context);
// Pega o sql para passar para o statement
final String sql = statusSql.construirSqlStatement(dadosStatus);
// Pega o argumento para o statement
final String[] argumentoSql = statusSql.argumentoStatement(dadosStatus);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//statusSql.insertOrReplace(dadosStatus);
statusSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
statusSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
statusSql.update(dadosStatus, "ID_CFASTATU = " + idStatu);
}
});
} else {
statusSql.update(dadosStatus, "ID_CFASTATU = " + idStatu);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
statusSql.delete("ID_CFASTATU = " + idStatu);
}
});
} else {
statusSql.delete("ID_CFASTATU = " + idStatu);
}
}
//dadosStatus.clear();
} // Fim Status
private void importarRegistroTipoDocumento(String linha){
Scanner scannerTipoDoc = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerTipoDoc.next();
final String idTpdoc = scannerTipoDoc.next();
String idEmpre = scannerTipoDoc.next();
String dtAlt = scannerTipoDoc.next();
String codigo = scannerTipoDoc.next();
String descricao = scannerTipoDoc.next();
String sigla = scannerTipoDoc.next();
String tipo = scannerTipoDoc.next();
// Libera memoria
scannerTipoDoc = null;
final ContentValues dadosTipoDoc = new ContentValues();
dadosTipoDoc.put("ID_CFATPDOC", idTpdoc);
dadosTipoDoc.put("ID_SMAEMPRE", idEmpre);
dadosTipoDoc.put("DT_ALT", dtAlt);
dadosTipoDoc.put("CODIGO", codigo);
dadosTipoDoc.put("DESCRICAO", descricao);
dadosTipoDoc.put("SIGLA", sigla);
dadosTipoDoc.put("TIPO", tipo);
final TipoDocumentoSql tipoDocumentoSql = new TipoDocumentoSql(context);
// Pega o sql para passar para o statement
final String sql = tipoDocumentoSql.construirSqlStatement(dadosTipoDoc);
// Pega o argumento para o statement
final String[] argumentoSql = tipoDocumentoSql.argumentoStatement(dadosTipoDoc);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//tipoDocumentoSql.insertOrReplace(dadosTipoDoc);
tipoDocumentoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
tipoDocumentoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
tipoDocumentoSql.update(dadosTipoDoc, "ID_CFATPDOC = " + idTpdoc);
}
});
} else {
tipoDocumentoSql.update(dadosTipoDoc, "ID_CFATPDOC = " + idTpdoc);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
tipoDocumentoSql.delete("ID_CFATPDOC = " + idTpdoc);
}
});
} else {
tipoDocumentoSql.delete("ID_CFATPDOC = " + idTpdoc);
}
}
} // FIm TipoDocumento
private void importarRegistroCartaoCredito(String linha){
Scanner scannerCartao = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerCartao.next();
final String idCred = scannerCartao.next();
String dtAlt = scannerCartao.next();
String codigo = scannerCartao.next();
String descricao = scannerCartao.next();
scannerCartao = null;
final ContentValues dadosCartao = new ContentValues();
dadosCartao.put("ID_CFACCRED", idCred);
dadosCartao.put("DT_ALT", dtAlt);
dadosCartao.put("CODIGO", codigo);
dadosCartao.put("DESCRICAO", descricao);
final CartaoSql cartaoSql = new CartaoSql(context);
// Pega o sql para passar para o statement
final String sql = cartaoSql.construirSqlStatement(dadosCartao);
// Pega o argumento para o statement
final String[] argumentoSql = cartaoSql.argumentoStatement(dadosCartao);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//cartaoSql.insertOrReplace(dadosCartao);
cartaoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
cartaoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
cartaoSql.update(dadosCartao, "ID_CFACCRED = " + idCred);
}
});
} else {
cartaoSql.update(dadosCartao, "ID_CFACCRED = " + idCred);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
cartaoSql.delete("ID_CFACCRED = " + idCred);
}
});
} else {
cartaoSql.delete("ID_CFACCRED = " + idCred);
}
}
}
private void importarRegistroPortador(String linha){
Scanner scannerPortador = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerPortador.next();
final String idPorta = scannerPortador.next();
String dtAlt = scannerPortador.next();
String codigo = scannerPortador.next();
String dg = scannerPortador.next();
String descricao = scannerPortador.next();
String sigla = scannerPortador.next();
String tipo = scannerPortador.next();
scannerPortador = null;
final ContentValues dadosPortador = new ContentValues();
dadosPortador.put("ID_CFAPORTA", idPorta);
dadosPortador.put("DT_ALT", dtAlt);
dadosPortador.put("CODIGO", codigo);
dadosPortador.put("DG", dg);
dadosPortador.put("DESCRICAO", descricao);
dadosPortador.put("SIGLA", sigla);
dadosPortador.put("TIPO", tipo);
final PortadorBancoSql portadorSql = new PortadorBancoSql(context);
// Pega o sql para passar para o statement
final String sql = portadorSql.construirSqlStatement(dadosPortador);
// Pega o argumento para o statement
final String[] argumentoSql = portadorSql.argumentoStatement(dadosPortador);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//portadorSql.insertOrReplace(dadosPortador);
portadorSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
portadorSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
portadorSql.update(dadosPortador, "ID_CFAPORTA = " + idPorta);
}
});
} else {
portadorSql.update(dadosPortador, "ID_CFAPORTA = " + idPorta);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
portadorSql.delete("ID_CFAPORTA = " + idPorta);
}
});
} else {
portadorSql.delete("ID_CFAPORTA = " + idPorta);
}
}
} // Fim Portador
private void importarRegistroProfissao(String linha){
Scanner scannerProfissao = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerProfissao.next();
final String idProfi = scannerProfissao.next();
String dtAlt = scannerProfissao.next();
String codigo = scannerProfissao.next();
String descricao = scannerProfissao.next();
String cbo = scannerProfissao.next();
String descAtacVista = scannerProfissao.next();
String descAtacPrazo = scannerProfissao.next();
String descVareVista = scannerProfissao.next();
String descVarePrazo = scannerProfissao.next();
String descPromocao = scannerProfissao.next();
scannerProfissao = null;
final ContentValues dadosProfissao = new ContentValues();
dadosProfissao.put("ID_CFAPROFI", idProfi);
dadosProfissao.put("DT_ALT", dtAlt);
dadosProfissao.put("CODIGO", codigo);
dadosProfissao.put("DESCRICAO", descricao);
dadosProfissao.put("CBO", cbo);
dadosProfissao.put("DESC_ATAC_VISTA", descAtacVista);
dadosProfissao.put("DESC_ATAC_PRAZO", descAtacPrazo);
dadosProfissao.put("DESC_VARE_VISTA", descVareVista);
dadosProfissao.put("DESC_VARE_PRAZO", descVarePrazo);
dadosProfissao.put("DESC_PROMOCAO", descPromocao);
final ProfissaoSql profissaoSql = new ProfissaoSql(context);
// Pega o sql para passar para o statement
final String sql = profissaoSql.construirSqlStatement(dadosProfissao);
// Pega o argumento para o statement
final String[] argumentoSql = profissaoSql.argumentoStatement(dadosProfissao);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//profissaoSql.insertOrReplace(dadosProfissao);
profissaoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
profissaoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
profissaoSql.update(dadosProfissao, "ID_CFAPROFI = " + idProfi);
}
});
} else {
profissaoSql.update(dadosProfissao, "ID_CFAPROFI = " + idProfi);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
profissaoSql.delete("ID_CFAPROFI = " + idProfi);
}
});
} else {
profissaoSql.delete("ID_CFAPROFI = " + idProfi);
}
}
}
private void importarRegistroTipoCliente(String linha){
Scanner scannerTipoCliente = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerTipoCliente.next();
final String idTpCli = scannerTipoCliente.next();
String dtAlt = scannerTipoCliente.next();
String codigo = scannerTipoCliente.next();
String descricao = scannerTipoCliente.next();
String descAtacVista = scannerTipoCliente.next();
String descAtacPrazo = scannerTipoCliente.next();
String descVareVista = scannerTipoCliente.next();
String descVarePrazo = scannerTipoCliente.next();
String descPromocao = scannerTipoCliente.next();
String vendeAtacVare = scannerTipoCliente.next();
scannerTipoCliente = null;
final ContentValues dadosTipoCliente = new ContentValues();
dadosTipoCliente.put("ID_CFATPCLI", idTpCli);
dadosTipoCliente.put("DT_ALT", dtAlt);
dadosTipoCliente.put("CODIGO", codigo);
dadosTipoCliente.put("DESCRICAO", descricao);
dadosTipoCliente.put("DESC_ATAC_VISTA", descAtacVista);
dadosTipoCliente.put("DESC_ATAC_PRAZO", descAtacPrazo);
dadosTipoCliente.put("DESC_VARE_VISTA", descVareVista);
dadosTipoCliente.put("DESC_VARE_PRAZO", descVarePrazo);
dadosTipoCliente.put("DESC_PROMOCAO", descPromocao);
dadosTipoCliente.put("VENDE_ATAC_VAREJO", vendeAtacVare);
final TipoClienteSql tipoClienteSql = new TipoClienteSql(context);
// Pega o sql para passar para o statement
final String sql = tipoClienteSql.construirSqlStatement(dadosTipoCliente);
// Pega o argumento para o statement
final String[] argumentoSql = tipoClienteSql.argumentoStatement(dadosTipoCliente);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//tipoClienteSql.insertOrReplace(dadosTipoCliente);
tipoClienteSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
tipoClienteSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
tipoClienteSql.update(dadosTipoCliente, "ID_CFATPCLI = " + idTpCli);
}
});
} else {
tipoClienteSql.update(dadosTipoCliente, "ID_CFATPCLI = " + idTpCli);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
tipoClienteSql.delete("ID_CFATPCLI = " + idTpCli);
}
});
} else {
tipoClienteSql.delete("ID_CFATPCLI = " + idTpCli);
}
}
} // Fim TipoCliente
private void importarRegistroEstado(String linha){
Scanner scannerEstado = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerEstado.next();
final String idEstad = scannerEstado.next();
String dtAlt = scannerEstado.next();
String uf = scannerEstado.next();
String descricao = scannerEstado.next();
String icmsSai = scannerEstado.next();
String tipoIpiSai = scannerEstado.next();
String IpiSai = scannerEstado.next();
String codIbge = scannerEstado.next();
scannerEstado = null;
final ContentValues dadosEstado = new ContentValues();
dadosEstado.put("ID_CFAESTAD", idEstad);
dadosEstado.put("DT_ALT", dtAlt);
dadosEstado.put("UF", uf);
dadosEstado.put("DESCRICAO", descricao);
dadosEstado.put("ICMS_SAI", icmsSai);
dadosEstado.put("TIPO_IPI_SAI", tipoIpiSai);
dadosEstado.put("IPI_SAI", IpiSai);
dadosEstado.put("COD_IBGE", codIbge);
final EstadoSql estadoSql = new EstadoSql(context);
// Pega o sql para passar para o statement
final String sql = estadoSql.construirSqlStatement(dadosEstado);
// Pega o argumento para o statement
final String[] argumentoSql = estadoSql.argumentoStatement(dadosEstado);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
estadoSql.insertOrReplace(dadosEstado);
}
});
} else {
estadoSql.insertOrReplace(dadosEstado);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
estadoSql.update(dadosEstado, "ID_CFAESTAD = " + idEstad);
}
});
} else {
estadoSql.update(dadosEstado, "ID_CFAESTAD = " + idEstad);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
estadoSql.delete("ID_CFAESTAD = " + idEstad);
}
});
} else {
estadoSql.delete("ID_CFAESTAD = " + idEstad);
}
}
} // Fim estado
private void importarRegistroCidade(String linha){
Scanner scannerCidade = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerCidade.next();
final String idCidade = scannerCidade.next();
String idEstad = scannerCidade.next();
String dtAlt = scannerCidade.next();
String descricao = scannerCidade.next();
String codIbge = scannerCidade.next();
scannerCidade.close();
/*final String sql = "INSERT OR REPLACE INTO CFACIDAD (ID_CFACIDAD, ID_CFAESTAD, DT_ALT, DESCRICAO, COD_IBGE) VALUES (" +
idEstad + ", " + idCidade + ", " + dtAlt + ", '" + descricao + "', " + codIbge + ")";*/
final ContentValues dadosCidade = new ContentValues();
dadosCidade.put("ID_CFACIDAD", idCidade);
dadosCidade.put("ID_CFAESTAD", idEstad);
dadosCidade.put("DT_ALT", dtAlt);
dadosCidade.put("DESCRICAO", descricao.replace("'", " "));
dadosCidade.put("COD_IBGE",codIbge);
final CidadeSql cidadeSql = new CidadeSql(context);
// Pega o sql para passar para o statement
final String sql = cidadeSql.construirSqlStatement(dadosCidade);
// Pega o argumento para o statement
final String[] argumentoSql = cidadeSql.argumentoStatement(dadosCidade);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//cidadeSql.insertOrReplace(dadosCidade);
cidadeSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
cidadeSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
cidadeSql.update(dadosCidade, "ID_CFACIDAD = " + idCidade);
}
});
} else {
cidadeSql.update(dadosCidade, "ID_CFACIDAD = " + idCidade);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
cidadeSql.delete("ID_CFACIDAD = " + idCidade);
}
});
} else {
cidadeSql.delete("ID_CFACIDAD = " + idCidade);
}
}
} // Fim Cidade
private void importarRegistroEndereco(String linha){
Scanner scannerEndereco = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerEndereco.next();
final String idEnder = scannerEndereco.next();
String idEstad = scannerEndereco.next();
String idCidad = scannerEndereco.next();
String idEmpre = scannerEndereco.next();
String idClifo = scannerEndereco.next();
String dtAlt = scannerEndereco.next();
String tipo = scannerEndereco.next();
String cep = scannerEndereco.next();
String bairro = scannerEndereco.next();
String logradouro = scannerEndereco.next();
String numero = scannerEndereco.next();
String complemento = scannerEndereco.next();
String email = scannerEndereco.next();
String letraCxPostal = scannerEndereco.next();
String caixaPostal = scannerEndereco.next();
scannerEndereco = null;
final ContentValues dadosEndereco = new ContentValues();
dadosEndereco.put("ID_CFAENDER", idEnder);
dadosEndereco.put("ID_CFAESTAD", idEstad);
dadosEndereco.put("ID_CFACIDAD", idCidad);
dadosEndereco.put("ID_SMAEMPRE", idEmpre);
dadosEndereco.put("ID_CFACLIFO", idClifo);
dadosEndereco.put("DT_ALT", dtAlt);
dadosEndereco.put("TIPO", tipo);
dadosEndereco.put("CEP", cep);
dadosEndereco.put("BAIRRO", bairro.replace("'", " "));
dadosEndereco.put("LOGRADOURO", logradouro);
dadosEndereco.put("NUMERO", numero);
dadosEndereco.put("COMPLEMENTO", complemento);
dadosEndereco.put("EMAIL", email);
dadosEndereco.put("LETRA_CX_POSTAL", letraCxPostal);
dadosEndereco.put("CAIXA_POSTAL", caixaPostal);
final EnderecoSql enderecoSql = new EnderecoSql(context);
// Pega o sql para passar para o statement
final String sql = enderecoSql.construirSqlStatement(dadosEndereco);
// Pega o argumento para o statement
final String[] argumentoSql = enderecoSql.argumentoStatement(dadosEndereco);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//enderecoSql.insertOrReplace(dadosEndereco);
enderecoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
enderecoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
enderecoSql.update(dadosEndereco, "ID_CFAENDER = " + idEnder);
}
});
} else {
enderecoSql.update(dadosEndereco, "ID_CFAENDER = " + idEnder);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
enderecoSql.delete("ID_CFAENDER = " + idEnder);
}
});
} else {
enderecoSql.delete("ID_CFAENDER = " + idEnder);
}
}
} // FIm Endereco
private void importarRegistroParametro(String linha){
Scanner scannerParametro = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerParametro.next();
final String idParam = scannerParametro.next();
String idClifo = scannerParametro.next();
String idEmpre = scannerParametro.next();
String idClifoVende = scannerParametro.next();
String idTpCob = scannerParametro.next();
String idPorta = scannerParametro.next();
String idTpDoc = scannerParametro.next();
String idPlPgt = scannerParametro.next();
String dtAlt = scannerParametro.next();
String vendeAtrazado = scannerParametro.next();
String limite = scannerParametro.next();
String descAtacVista = scannerParametro.next();
String descAtacPrazo = scannerParametro.next();
String descVareVista = scannerParametro.next();
String descVarePrazo = scannerParametro.next();
String descPromocao = scannerParametro.next();
String roteiro = scannerParametro.next();
String frequencia = scannerParametro.next();
String dtUltimaVisita = scannerParametro.next();
String dtUltimoEnvio = scannerParametro.next();
String dtUltimoRecebto = scannerParametro.next();
String dtProximoContato = scannerParametro.next();
String diasAtrazo = scannerParametro.next();
String diasCarencia = scannerParametro.next();
String jurosDiario = scannerParametro.next();
String atacadoVarejo = scannerParametro.next();
String vistaPrazo = scannerParametro.next();
String faturaVlMin = scannerParametro.next();
String parcelaAberto = scannerParametro.next();
scannerParametro = null;
final ContentValues dadosParametro = new ContentValues();
dadosParametro.put("ID_CFAPARAM", idParam);
dadosParametro.put("ID_CFACLIFO", idClifo);
dadosParametro.put("ID_SMAEMPRE", idEmpre);
dadosParametro.put("ID_CFACLIFO_VENDE", idClifoVende);
dadosParametro.put("ID_CFATPCOB", idTpCob);
dadosParametro.put("ID_CFAPORTA", idPorta);
dadosParametro.put("ID_CFATPDOC", idTpDoc);
dadosParametro.put("ID_AEAPLPGT", idPlPgt);
dadosParametro.put("DT_ALT", dtAlt);
dadosParametro.put("VENDE_ATRAZADO", vendeAtrazado);
dadosParametro.put("LIMITE", limite);
dadosParametro.put("DESC_ATAC_VISTA", descAtacVista);
dadosParametro.put("DESC_ATAC_PRAZO", descAtacPrazo);
dadosParametro.put("DESC_VARE_VISTA", descVareVista);
dadosParametro.put("DESC_VARE_PRAZO", descVarePrazo);
dadosParametro.put("DESC_PROMOCAO", descPromocao);
dadosParametro.put("ROTEIRO", roteiro);
dadosParametro.put("FREQUENCIA", frequencia);
dadosParametro.put("DT_ULT_VISITA", dtUltimaVisita.replace("0000-00-00", ""));
dadosParametro.put("DT_ULT_ENVIO", dtUltimoEnvio.replace("0000-00-00", ""));
dadosParametro.put("DT_ULT_RECEBTO", dtUltimoRecebto.replace("0000-00-00", ""));
dadosParametro.put("DT_PROXIMO_CONTATO", dtProximoContato.replace("0000-00-00", ""));
dadosParametro.put("DIAS_ATRAZO", diasAtrazo);
dadosParametro.put("DIAS_CARENCIA", diasCarencia);
dadosParametro.put("JUROS_DIARIO", jurosDiario);
dadosParametro.put("ATACADO_VAREJO", atacadoVarejo);
dadosParametro.put("VISTA_PRAZO", vistaPrazo);
dadosParametro.put("FATURA_VL_MIN", faturaVlMin);
dadosParametro.put("PARCELA_EM_ABERTO", parcelaAberto);
final ParametrosSql parametrosSql = new ParametrosSql(context);
// Pega o sql para passar para o statement
final String sql = parametrosSql.construirSqlStatement(dadosParametro);
// Pega o argumento para o statement
final String[] argumentoSql = parametrosSql.argumentoStatement(dadosParametro);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//parametrosSql.insertOrReplace(dadosParametro);
parametrosSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
parametrosSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
parametrosSql.update(dadosParametro, "ID_CFAPARAM = " + idParam);
}
});
} else {
parametrosSql.update(dadosParametro, "ID_CFAPARAM = " + idParam);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
parametrosSql.delete("ID_CFAPARAM = " + idParam);
}
});
} else {
parametrosSql.delete("ID_CFAPARAM = " + idParam);
}
}
} // Fim Parametros
private void importarRegistroFotos(String linha){
Scanner scannerFotos = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerFotos.next();
final String idFoto = scannerFotos.next();
String idClifo = scannerFotos.next();
String idProduto = scannerFotos.next();
String dtAlt = scannerFotos.next();
String foto = scannerFotos.next();
final ContentValues dadosFoto = new ContentValues();
dadosFoto.put("ID_CFAFOTOS", idFoto);
dadosFoto.put("ID_CFACLIFO", idClifo);
dadosFoto.put("ID_AEAPRODU", idProduto);
dadosFoto.put("DT_ALT", dtAlt);
dadosFoto.put("FOTO", foto);
final FotosSql fotosSql = new FotosSql(context);
// Pega o sql para passar para o statement
final String sql = fotosSql.construirSqlStatement(dadosFoto);
// Pega o argumento para o statement
final String[] argumentoSql = fotosSql.argumentoStatement(dadosFoto);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//fotosSql.insertOrReplace(dadosFoto);
fotosSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
fotosSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
fotosSql.update(dadosFoto, "ID_CFAFOTOS = " + idFoto);
}
});
} else {
fotosSql.update(dadosFoto, "ID_CFAFOTOS = " + idFoto);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
fotosSql.delete("ID_CFAFOTOS = " + idFoto);
}
});
} else {
fotosSql.delete("ID_CFAFOTOS = " + idFoto);
}
}
}
private void importarRegistroClasse(String linha){
Scanner scannerClasse = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerClasse.next();
final String idClase = scannerClasse.next();
String dtAlt = scannerClasse.next();
String codigo = scannerClasse.next();
String descricao = scannerClasse.next();
final ContentValues dadosClasse = new ContentValues();
dadosClasse.put("ID_AEACLASE", idClase);
dadosClasse.put("DT_ALT", dtAlt);
dadosClasse.put("CODIGO", codigo);
dadosClasse.put("DESCRICAO", descricao);
final ClasseSql classeSql = new ClasseSql(context);
// Pega o sql para passar para o statement
final String sql = classeSql.construirSqlStatement(dadosClasse);
// Pega o argumento para o statement
final String[] argumentoSql = classeSql.argumentoStatement(dadosClasse);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//classeSql.insertOrReplace(dadosClasse);
classeSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
classeSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
classeSql.update(dadosClasse, "ID_AEACLASE = " + idClase);
}
});
} else {
classeSql.update(dadosClasse, "ID_AEACLASE = " + idClase);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
classeSql.delete("ID_AEACLASE = " + idClase);
}
});
} else {
classeSql.delete("ID_AEACLASE = " + idClase);
}
}
} // FIm classe
private void importarRegistroUnidadeVenda(String linha){
Scanner scannerUnVenda = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerUnVenda.next();
final String idUnVen = scannerUnVenda.next();
String dtAlt = scannerUnVenda.next();
String sigla = scannerUnVenda.next();
String descricao = scannerUnVenda.next();
String decimais = scannerUnVenda.next();
scannerUnVenda = null;
final ContentValues dadosUnVenda = new ContentValues();
dadosUnVenda.put("ID_AEAUNVEN", idUnVen);
dadosUnVenda.put("DT_ALT", dtAlt);
dadosUnVenda.put("SIGLA", sigla);
dadosUnVenda.put("DESCRICAO_SINGULAR", descricao);
dadosUnVenda.put("DECIMAIS", decimais);
final UnidadeVendaSql unVendaSql = new UnidadeVendaSql(context);
// Pega o sql para passar para o statement
final String sql = unVendaSql.construirSqlStatement(dadosUnVenda);
// Pega o argumento para o statement
final String[] argumentoSql = unVendaSql.argumentoStatement(dadosUnVenda);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//unVendaSql.insertOrReplace(dadosUnVenda);
unVendaSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
unVendaSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
unVendaSql.update(dadosUnVenda, "ID_AEAUNVEN = " + idUnVen);
}
});
} else {
unVendaSql.update(dadosUnVenda, "ID_AEAUNVEN = " + idUnVen);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
unVendaSql.delete("ID_AEAUNVEN = " + idUnVen);
}
});
} else {
unVendaSql.delete("ID_AEAUNVEN = " + idUnVen);
}
}
} // Fim UnidadeVenda
private void importarRegistroEstoque(String linha){
Scanner scannerEstoque = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerEstoque.next();
final String idEstoq = scannerEstoque.next();
String idPloja = scannerEstoque.next();
String idLoces = scannerEstoque.next();
String dtAlt = scannerEstoque.next();
String estoque = scannerEstoque.next();
String retido = scannerEstoque.next();
String ativo = scannerEstoque.next();
scannerEstoque = null;
final ContentValues dadosEstoque = new ContentValues();
dadosEstoque.put("ID_AEAESTOQ", idEstoq);
dadosEstoque.put("ID_AEAPLOJA", idPloja);
dadosEstoque.put("ID_AEALOCES", idLoces);
dadosEstoque.put("DT_ALT", dtAlt);
dadosEstoque.put("ESTOQUE", estoque);
dadosEstoque.put("RETIDO", retido);
dadosEstoque.put("ATIVO", ativo);
final EstoqueSql estoqueSql = new EstoqueSql(context);
// Pega o sql para passar para o statement
final String sql = estoqueSql.construirSqlStatement(dadosEstoque);
// Pega o argumento para o statement
final String[] argumentoSql = estoqueSql.argumentoStatement(dadosEstoque);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//estoqueSql.insertOrReplace(dadosEstoque);
estoqueSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
estoqueSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
estoqueSql.update(dadosEstoque, "ID_AEAESTOQ = " + idEstoq);
}
});
} else {
estoqueSql.update(dadosEstoque, "ID_AEAESTOQ = " + idEstoq);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
estoqueSql.delete("ID_AEAESTOQ = " + idEstoq);
}
});
} else {
estoqueSql.delete("ID_AEAESTOQ = " + idEstoq);
}
}
} // Fim Estoque
private void importarRegistroOrcamento(String linha){
Scanner scannerOrcamento = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerOrcamento.next();
final String guid = scannerOrcamento.next();
String idEmpre = scannerOrcamento.next();
String idClifo = scannerOrcamento.next();
String idEstado = scannerOrcamento.next();
String idCidade = scannerOrcamento.next();
String idRomaneio = scannerOrcamento.next();
String idTipoDocumento = scannerOrcamento.next();
String dataAlt = scannerOrcamento.next();
String atacVarejo = scannerOrcamento.next();
String numero = scannerOrcamento.next();
String valorTabelaFaturado = scannerOrcamento.next();
String valorFaturado = scannerOrcamento.next();
String pessoaCliente = scannerOrcamento.next();
String nomeCliente = scannerOrcamento.next();
String ieRgCliente = scannerOrcamento.next();
String cpfCgcCliente = scannerOrcamento.next();
String enderecoCliente = scannerOrcamento.next();
String bairroCliente = scannerOrcamento.next();
String cepCliente = scannerOrcamento.next();
String obs = scannerOrcamento.next();
String tipoEntrega = scannerOrcamento.next();
String statusRetorno = scannerOrcamento.next();
scannerOrcamento = null;
final ContentValues dadosOrcamento = new ContentValues();
dadosOrcamento.put("GUID", guid);
dadosOrcamento.put("ID_SMAEMPRE", idEmpre);
dadosOrcamento.put("ID_CFACLIFO", idClifo);
dadosOrcamento.put("ID_CFAESTAD", idEstado);
dadosOrcamento.put("ID_CFACIDAD", idCidade);
dadosOrcamento.put("ID_AEAROMAN", idRomaneio);
dadosOrcamento.put("ID_CFATPDOC", idTipoDocumento);
dadosOrcamento.put("DT_ALT", dataAlt);
dadosOrcamento.put("ATAC_VAREJO", atacVarejo);
dadosOrcamento.put("NUMERO", numero);
dadosOrcamento.put("VL_TABELA_FATURADO", valorTabelaFaturado);
dadosOrcamento.put("FC_VL_TOTAL_FATURADO", valorFaturado);
dadosOrcamento.put("PESSOA_CLIENTE", pessoaCliente);
dadosOrcamento.put("NOME_CLIENTE", nomeCliente);
dadosOrcamento.put("IE_RG_CLIENTE", ieRgCliente);
dadosOrcamento.put("CPF_CGC_CLIENTE", cpfCgcCliente);
dadosOrcamento.put("ENDERECO_CLIENTE", enderecoCliente);
dadosOrcamento.put("BAIRRO_CLIENTE", bairroCliente);
dadosOrcamento.put("CEP_CLIENTE", cepCliente);
dadosOrcamento.put("OBS", obs);
dadosOrcamento.put("TIPO_ENTREGA", tipoEntrega);
dadosOrcamento.put("STATUS_RETORNO", statusRetorno);
final OrcamentoSql orcamentoSql = new OrcamentoSql(context);
// Pega o sql para passar para o statement
final String sql = orcamentoSql.construirSqlStatement(dadosOrcamento);
// Pega o argumento para o statement
final String[] argumentoSql = orcamentoSql.argumentoStatement(dadosOrcamento);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//gradeSql.insertOrReplace(dadosGrade);
orcamentoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
orcamentoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
orcamentoSql.update(dadosOrcamento, "GUID = '" + guid + "'");
}
});
} else {
orcamentoSql.update(dadosOrcamento, "GUID = '" + guid + "'");
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
orcamentoSql.delete("GUID = " + guid);
}
});
} else {
orcamentoSql.delete("GUID = " + guid);
}
}
} // Fim importarRegistroOrcamento
private void importarRegistroItemOrcamento(String linha){
Scanner scannerOrcamento = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerOrcamento.next();
final String guid = scannerOrcamento.next();
String idOrcamento = scannerOrcamento.next();
String idEstoque = scannerOrcamento.next();
String idPlanoPagamento = scannerOrcamento.next();
String idUnidadeVenda = scannerOrcamento.next();
//String dtAlt = scannerOrcamento.next();
String quantidade = scannerOrcamento.next();
String vlTabalaFaturado = scannerOrcamento.next();
String vlLiquidoFaturado = scannerOrcamento.next();
String complemento = scannerOrcamento.next();
String seqDesconto = scannerOrcamento.next();
String statusRetorno = scannerOrcamento.next();
final ContentValues dadosItemOrcamento = new ContentValues();
dadosItemOrcamento.put("GUID", guid);
dadosItemOrcamento.put("ID_AEAORCAM", idOrcamento);
dadosItemOrcamento.put("ID_AEAESTOQ", idEstoque);
dadosItemOrcamento.put("ID_AEAPLPGT", idPlanoPagamento);
dadosItemOrcamento.put("ID_AEAUNVEN", idUnidadeVenda);
//dadosItemOrcamento.put("DT_ALT", dtAlt);
dadosItemOrcamento.put("QUANTIDADE_FATURADA", quantidade);
dadosItemOrcamento.put("VL_TABELA_FATURADO", vlTabalaFaturado);
dadosItemOrcamento.put("FC_LIQUIDO_FATURADO", vlLiquidoFaturado);
dadosItemOrcamento.put("COMPLEMENTO", complemento);
dadosItemOrcamento.put("SEQ_DESCONTO", seqDesconto);
dadosItemOrcamento.put("STATUS_RETORNO", statusRetorno);
final ItemOrcamentoSql itemOrcamentoSql = new ItemOrcamentoSql(context);
// Pega o sql para passar para o statement
final String sql = itemOrcamentoSql.construirSqlStatement(dadosItemOrcamento);
// Pega o argumento para o statement
final String[] argumentoSql = itemOrcamentoSql.argumentoStatement(dadosItemOrcamento);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//gradeSql.insertOrReplace(dadosGrade);
itemOrcamentoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
itemOrcamentoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
itemOrcamentoSql.update(dadosItemOrcamento, "GUID = '" + guid + "'");
}
});
} else {
itemOrcamentoSql.update(dadosItemOrcamento, "GUID = '" + guid + "'");
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
itemOrcamentoSql.delete("GUID = " + guid);
}
});
} else {
itemOrcamentoSql.delete("GUID = " + guid);
}
}
}
private void importarRegistroPercentual(String linha){
Scanner scannerPercen = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerPercen.next();
final String idPercentual = scannerPercen.next();
String idEmpresa = scannerPercen.next();
String idClasse = scannerPercen.next();
String idMarca = scannerPercen.next();
String idProduto = scannerPercen.next();
String idLoja = scannerPercen.next();
String idParamVendedor = scannerPercen.next();
String dtAlt = scannerPercen.next();
String custoFixo = scannerPercen.next();
String impostosFederais = scannerPercen.next();
String markupVarejo = scannerPercen.next();
String markupAtacado = scannerPercen.next();
String lucroVarejo = scannerPercen.next();
String lucroAtacado = scannerPercen.next();
String descontoVistaVarejo = scannerPercen.next();
String descontoVistaAtacado = scannerPercen.next();
String descontoPrazoVarejo = scannerPercen.next();
String descontoPrazoAtacado = scannerPercen.next();
final ContentValues dadosItemOrcamento = new ContentValues();
dadosItemOrcamento.put("ID_AEAPERCE", idPercentual);
dadosItemOrcamento.put("ID_SMAEMPRE", idEmpresa);
dadosItemOrcamento.put("ID_AEACLASE", idClasse);
dadosItemOrcamento.put("ID_AEAMARCA", idClasse);
dadosItemOrcamento.put("ID_AEAPRODU", idProduto);
dadosItemOrcamento.put("ID_AEAPLOJA", idLoja);
dadosItemOrcamento.put("ID_CFAPARAM_VENDEDOR", idParamVendedor);
dadosItemOrcamento.put("DT_ALT", dtAlt);
dadosItemOrcamento.put("CUSTO_FIXO", custoFixo);
dadosItemOrcamento.put("IMPOSTOS_FEDERAIS", impostosFederais);
dadosItemOrcamento.put("MARKUP_VARE", markupVarejo);
dadosItemOrcamento.put("MARKUP_ATAC", markupAtacado);
dadosItemOrcamento.put("LUCRO_VARE", lucroVarejo);
dadosItemOrcamento.put("LUCRO_ATAC", lucroAtacado);
dadosItemOrcamento.put("DESC_MERC_VISTA_VARE", descontoVistaVarejo);
dadosItemOrcamento.put("DESC_MERC_VISTA_ATAC", descontoVistaAtacado);
dadosItemOrcamento.put("DESC_MERC_PRAZO_VARE", descontoPrazoVarejo);
dadosItemOrcamento.put("DESC_MERC_PRAZO_ATAC", descontoPrazoAtacado);
final PercentualSql percentualSql = new PercentualSql(context);
// Pega o sql para passar para o statement
final String sql = percentualSql.construirSqlStatement(dadosItemOrcamento);
// Pega o argumento para o statement
final String[] argumentoSql = percentualSql.argumentoStatement(dadosItemOrcamento);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//gradeSql.insertOrReplace(dadosGrade);
percentualSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
percentualSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
percentualSql.update(dadosItemOrcamento, "ID_AEAPERCE = " + idPercentual);
}
});
} else {
percentualSql.update(dadosItemOrcamento, "ID_AEAPERCE = " + idPercentual);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
percentualSql.delete("ID_AEAPERCE = " + idPercentual);
}
});
} else {
percentualSql.delete("ID_AEAPERCE = " + idPercentual);
}
}
}
private void importarRegistroProdutoRecomendado(String linha){
Scanner scannerGrade = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerGrade.next();
final String idRecomenda = scannerGrade.next();
String idPRoduto = scannerGrade.next();
String idAreas = scannerGrade.next();
String idCidade = scannerGrade.next();
String idVendedor = scannerGrade.next();
String idCliente = scannerGrade.next();
String idEmpresa = scannerGrade.next();
String posicao = scannerGrade.next();
final ContentValues dadosProdutoRec = new ContentValues();
dadosProdutoRec.put("ID_AEAPRREC", idRecomenda);
dadosProdutoRec.put("ID_AEAPRODU", idPRoduto);
dadosProdutoRec.put("ID_CFAAREAS", idAreas);
dadosProdutoRec.put("ID_CFACIDAD", idCidade);
dadosProdutoRec.put("ID_CFACLIFO_VENDEDOR", idVendedor);
dadosProdutoRec.put("ID_CFACLIFO", idCliente);
dadosProdutoRec.put("ID_SMAEMPRE", idEmpresa);
dadosProdutoRec.put("POSICAO", posicao);
final ProdutoRecomendadoSql produtoRecomendadoSql = new ProdutoRecomendadoSql(context);
// Pega o sql para passar para o statement
final String sql = produtoRecomendadoSql.construirSqlStatement(dadosProdutoRec);
// Pega o argumento para o statement
final String[] argumentoSql = produtoRecomendadoSql.argumentoStatement(dadosProdutoRec);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//gradeSql.insertOrReplace(dadosGrade);
produtoRecomendadoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
produtoRecomendadoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
produtoRecomendadoSql.update(dadosProdutoRec, "ID_AEAPRREC = " + idRecomenda);
}
});
} else {
produtoRecomendadoSql.update(dadosProdutoRec, "ID_AEAPRREC = " + idRecomenda);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
produtoRecomendadoSql.delete("ID_AEAPRREC = " + idRecomenda);
}
});
} else {
produtoRecomendadoSql.delete("ID_AEAPRREC = " + idRecomenda);
}
}
}
private void importarRegistroGrade(String linha){
Scanner scannerGrade = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerGrade.next();
final String idGrade = scannerGrade.next();
String idTpGrd = scannerGrade.next();
String dtAlt = scannerGrade.next();
String descricao = scannerGrade.next();
scannerGrade = null;
final ContentValues dadosGrade = new ContentValues();
dadosGrade.put("ID_AEAGRADE", idGrade);
dadosGrade.put("ID_AEATPGRD", idTpGrd);
dadosGrade.put("DT_ALT", dtAlt);
dadosGrade.put("DESCRICAO", descricao);
final GradeSql gradeSql = new GradeSql(context);
// Pega o sql para passar para o statement
final String sql = gradeSql.construirSqlStatement(dadosGrade);
// Pega o argumento para o statement
final String[] argumentoSql = gradeSql.argumentoStatement(dadosGrade);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//gradeSql.insertOrReplace(dadosGrade);
gradeSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
gradeSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
gradeSql.update(dadosGrade, "ID_AEAGRADE = " + idGrade);
}
});
} else {
gradeSql.update(dadosGrade, "ID_AEAGRADE = " + idGrade);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
gradeSql.delete("ID_AEAGRADE = " + idGrade);
}
});
} else {
gradeSql.delete("ID_AEAGRADE = " + idGrade);
}
}
} // FIm grade
private void importarRegistroMarca(String linha){
Scanner scannerMarca = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerMarca.next();
final String idMarca = scannerMarca.next();
String dtAlt = scannerMarca.next();
String descricao = scannerMarca.next();
scannerMarca = null;
final ContentValues dadosMarca = new ContentValues();
dadosMarca.put("ID_AEAMARCA", idMarca);
dadosMarca.put("DT_ALT", dtAlt);
dadosMarca.put("DESCRICAO", descricao);
final MarcaSql marcaSql= new MarcaSql(context);
// Pega o sql para passar para o statement
final String sql = marcaSql.construirSqlStatement(dadosMarca);
// Pega o argumento para o statement
final String[] argumentoSql = marcaSql.argumentoStatement(dadosMarca);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//marcaSql.insertOrReplace(dadosMarca);
marcaSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
marcaSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
marcaSql.update(dadosMarca, "ID_AEAMARCA = " + idMarca);
}
});
} else {
marcaSql.update(dadosMarca, "ID_AEAMARCA = " + idMarca);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
marcaSql.delete("ID_AEAMARCA = " + idMarca);
}
});
} else {
marcaSql.delete("ID_AEAMARCA = " + idMarca);
}
}
} // FIm Marca
private void importarRegistroProduto(String linha){
Scanner scannerProduto = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerProduto.next();
final String idProdu = scannerProduto.next();
String idClase = scannerProduto.next();
String idMarca = scannerProduto.next();
String idUnVen = scannerProduto.next();
String dtCad = scannerProduto.next();
String dtAlt = scannerProduto.next();
String descricao = scannerProduto.next();
String descricaoAuxiliar = scannerProduto.next();
String codigoEstrutural = scannerProduto.next();
String referencia = scannerProduto.next();
String codigoBarras = scannerProduto.next();
String pesoLiquido = scannerProduto.next();
String pesoBruto = scannerProduto.next();
String ativo = scannerProduto.next();
String tipo = scannerProduto.next();
scannerProduto = null;
final ContentValues dadosProduto = new ContentValues();
dadosProduto.put("ID_AEAPRODU", idProdu);
dadosProduto.put("ID_AEACLASE", idClase);
dadosProduto.put("ID_AEAMARCA", idMarca);
dadosProduto.put("ID_AEAUNVEN", idUnVen);
dadosProduto.put("DT_CAD", dtCad);
dadosProduto.put("DT_ALT", dtAlt);
dadosProduto.put("DESCRICAO", descricao);
dadosProduto.put("DESCRICAO_AUXILIAR", descricaoAuxiliar);
dadosProduto.put("CODIGO_ESTRUTURAL", codigoEstrutural);
dadosProduto.put("REFERENCIA", referencia);
dadosProduto.put("CODIGO_BARRAS", codigoBarras);
dadosProduto.put("PESO_LIQUIDO", pesoLiquido);
dadosProduto.put("PESO_BRUTO", pesoBruto);
dadosProduto.put("ATIVO", ativo);
dadosProduto.put("TIPO", tipo);
final ProdutoSql produtoSql = new ProdutoSql(context);
// Pega o sql para passar para o statement
final String sql = produtoSql.construirSqlStatement(dadosProduto);
// Pega o argumento para o statement
final String[] argumentoSql = produtoSql.argumentoStatement(dadosProduto);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//produtoSql.insertOrReplace(dadosProduto);
produtoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
produtoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
produtoSql.update(dadosProduto, "ID_AEAPRODU = " + idProdu);
}
});
} else {
produtoSql.update(dadosProduto, "ID_AEAPRODU = " + idProdu);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
produtoSql.delete("ID_AEAPRODU = " + idProdu);
}
});
} else {
produtoSql.delete("ID_AEAPRODU = " + idProdu);
}
}
} // Fim Produto
private void importarRegistroEmbalagem(String linha){
Scanner scannerEmbalagem = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerEmbalagem.next();
final String idEmbal = scannerEmbalagem.next();
String idProdu = scannerEmbalagem.next();
String idUnven = scannerEmbalagem.next();
String dtAlt = scannerEmbalagem.next();
String principal = scannerEmbalagem.next();
String descricao = scannerEmbalagem.next();
String fatorConversao = scannerEmbalagem.next();
String fatorPreco = scannerEmbalagem.next();
String modulo = scannerEmbalagem.next();
String decimais = scannerEmbalagem.next();
String ativo = scannerEmbalagem.next();
scannerEmbalagem = null;
final ContentValues dadosEmbal = new ContentValues();
dadosEmbal.put("ID_AEAEMBAL", idEmbal);
dadosEmbal.put("ID_AEAPRODU", idProdu);
dadosEmbal.put("ID_AEAUNVEN", idUnven);
dadosEmbal.put("DT_ALT", dtAlt);
dadosEmbal.put("PRINCIPAL", principal);
dadosEmbal.put("DESCRICAO", descricao);
dadosEmbal.put("FATOR_CONVERSAO", fatorConversao);
dadosEmbal.put("FATOR_PRECO", fatorPreco);
dadosEmbal.put("MODULO", modulo);
dadosEmbal.put("DECIMAIS", decimais);
dadosEmbal.put("ATIVO", ativo);
final EmbalagemSql embalagemSql = new EmbalagemSql(context);
// Pega o sql para passar para o statement
final String sql = embalagemSql.construirSqlStatement(dadosEmbal);
// Pega o argumento para o statement
final String[] argumentoSql = embalagemSql.argumentoStatement(dadosEmbal);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//embalagemSql.insertOrReplace(dadosEmbal);
embalagemSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
embalagemSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
embalagemSql.update(dadosEmbal, "ID_AEAEMBAL = " + idEmbal);
}
});
} else {
embalagemSql.update(dadosEmbal, "ID_AEAEMBAL = " + idEmbal);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
embalagemSql.delete("ID_AEAEMBAL = " + idEmbal);
}
});
} else {
embalagemSql.delete("ID_AEAEMBAL = " + idEmbal);
}
}
} // FIm embalagem
private void importarRegistroPLoja(String linha){
Scanner scannerPLoja = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerPLoja.next();
final String idPLoja = scannerPLoja.next();
String idEmpre = scannerPLoja.next();
String idProdu = scannerPLoja.next();
String idCodSt = scannerPLoja.next();
String dtAlt = scannerPLoja.next();
String estoqueF = scannerPLoja.next();
String estoqueC = scannerPLoja.next();
String retido = scannerPLoja.next();
String pedido = scannerPLoja.next();
String ativo = scannerPLoja.next();
String dtEntradaD = scannerPLoja.next();
String dtEntradaN = scannerPLoja.next();
String ctReposicaoN = scannerPLoja.next();
String ctCompletoN = scannerPLoja.next();
String vendaAtac = scannerPLoja.next();
String vendaVare = scannerPLoja.next();
String promocaoAtac = scannerPLoja.next();
String promocaoVare = scannerPLoja.next();
String precoMinAtac = scannerPLoja.next();
String precoMinVare = scannerPLoja.next();
String precoMaxAtac = scannerPLoja.next();
String precoMaxVare = scannerPLoja.next();
scannerPLoja = null;
final ContentValues dadosPLoja = new ContentValues();
dadosPLoja.put("ID_AEAPLOJA", idPLoja);
dadosPLoja.put("ID_SMAEMPRE", idEmpre);
dadosPLoja.put("ID_AEAPRODU", idProdu);
dadosPLoja.put("ID_AEACODST", idCodSt);
dadosPLoja.put("DT_ALT", dtAlt);
dadosPLoja.put("ESTOQUE_F", estoqueF);
dadosPLoja.put("ESTOQUE_C", estoqueC);
dadosPLoja.put("RETIDO", retido);
dadosPLoja.put("PEDIDO", pedido);
dadosPLoja.put("ATIVO", ativo);
dadosPLoja.put("DT_ENTRADA_D", dtEntradaD.replace("0000-00-00", ""));
dadosPLoja.put("DT_ENTRADA_N", dtEntradaN.replace("0000-00-00", ""));
dadosPLoja.put("CT_REPOSICAO_N", ctReposicaoN);
dadosPLoja.put("CT_COMPLETO_N", ctCompletoN);
dadosPLoja.put("VENDA_ATAC", vendaAtac);
dadosPLoja.put("VENDA_VARE", vendaVare);
dadosPLoja.put("PROMOCAO_ATAC", promocaoAtac);
dadosPLoja.put("PROMOCAO_VARE", promocaoVare);
dadosPLoja.put("PRECO_MINIMO_ATAC", precoMinAtac);
dadosPLoja.put("PRECO_MINIMO_VARE", precoMinVare);
dadosPLoja.put("PRECO_MAXIMO_ATAC", precoMaxAtac);
dadosPLoja.put("PRECO_MAXIMO_VARE", precoMaxVare);
final ProdutoLojaSql produtoLojaSql = new ProdutoLojaSql(context);
// Pega o sql para passar para o statement
final String sql = produtoLojaSql.construirSqlStatement(dadosPLoja);
// Pega o argumento para o statement
final String[] argumentoSql = produtoLojaSql.argumentoStatement(dadosPLoja);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//produtoLojaSql.insertOrReplace(dadosPLoja);
produtoLojaSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
produtoLojaSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
produtoLojaSql.update(dadosPLoja, "ID_AEAPLOJA = " + idPLoja);
}
});
} else {
produtoLojaSql.update(dadosPLoja, "ID_AEAPLOJA = " + idPLoja);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
produtoLojaSql.delete("ID_AEAPLOJA = " + idPLoja);
}
});
} else {
produtoLojaSql.delete("ID_AEAPLOJA = " + idPLoja);
}
}
} // Fim PLoja
private void importarRegistroPlanoPgto(String linha){
Scanner scannerPlanoPgto = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerPlanoPgto.next();
final String idPlPgt = scannerPlanoPgto.next();
String idEmpre = scannerPlanoPgto.next();
String dtAlt = scannerPlanoPgto.next();
String codigo = scannerPlanoPgto.next();
String descricao = scannerPlanoPgto.next();
String ativo = scannerPlanoPgto.next();
String atacVarejo = scannerPlanoPgto.next();
String vistaPrazo = scannerPlanoPgto.next();
String percDescAtac = scannerPlanoPgto.next();
String percDescVare = scannerPlanoPgto.next();
String descPromocao = scannerPlanoPgto.next();
String juroMedioAtac = scannerPlanoPgto.next();
String juroMedioVare = scannerPlanoPgto.next();
String diasMedio = scannerPlanoPgto.next();
scannerPlanoPgto = null;
final ContentValues dadosPlanoPgto = new ContentValues();
dadosPlanoPgto.put("ID_AEAPLPGT", idPlPgt);
dadosPlanoPgto.put("ID_SMAEMPRE", idEmpre);
dadosPlanoPgto.put("DT_ALT", dtAlt);
dadosPlanoPgto.put("CODIGO", codigo);
dadosPlanoPgto.put("DESCRICAO", descricao);
dadosPlanoPgto.put("ATIVO", ativo);
dadosPlanoPgto.put("ATAC_VAREJO", atacVarejo);
dadosPlanoPgto.put("VISTA_PRAZO", vistaPrazo);
dadosPlanoPgto.put("PERC_DESC_ATAC", percDescAtac);
dadosPlanoPgto.put("PERC_DESC_VARE", percDescVare);
dadosPlanoPgto.put("DESC_PROMOCAO", descPromocao);
dadosPlanoPgto.put("JURO_MEDIO_ATAC", juroMedioAtac);
dadosPlanoPgto.put("JURO_MEDIO_VARE", juroMedioVare);
dadosPlanoPgto.put("DIAS_MEDIOS", diasMedio);
final PlanoPagamentoSql pagamentoSql = new PlanoPagamentoSql(context);
// Pega o sql para passar para o statement
final String sql = pagamentoSql.construirSqlStatement(dadosPlanoPgto);
// Pega o argumento para o statement
final String[] argumentoSql = pagamentoSql.argumentoStatement(dadosPlanoPgto);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//pagamentoSql.insertOrReplace(dadosPlanoPgto);
pagamentoSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
pagamentoSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
pagamentoSql.update(dadosPlanoPgto, "ID_AEAPLPGT = " + idPlPgt);
}
});
} else {
pagamentoSql.update(dadosPlanoPgto, "ID_AEAPLPGT = " + idPlPgt);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
pagamentoSql.delete("ID_AEAPLPGT = " + idPlPgt);
}
});
} else {
pagamentoSql.delete("ID_AEAPLPGT = " + idPlPgt);
}
}
} // Fim PlanoPgto
private void importarRegistroParcela(String linha){
Scanner scannerParcela = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerParcela.next();
final String idParce = scannerParcela.next();
String idEmpre = scannerParcela.next();
String idFatur = scannerParcela.next();
String idClifo = scannerParcela.next();
String idTpDoc = scannerParcela.next();
String idTpCob = scannerParcela.next();
String idPorta = scannerParcela.next();
String dtAlta = scannerParcela.next();
String tipo = scannerParcela.next();
String dtEmissao = scannerParcela.next();
String dtVencimento = scannerParcela.next();
String dtBaixa = scannerParcela.next();
String parcela = scannerParcela.next();
String vlParcela = scannerParcela.next();
String vlTotalPago = scannerParcela.next();
String vlRestante = scannerParcela.next();
String vlJurosDiario = scannerParcela.next();
String percDesconto = scannerParcela.next();
String sequencial = scannerParcela.next();
String numero = scannerParcela.next();
String obs = scannerParcela.next();
scannerParcela = null;
final ContentValues dadosParcela = new ContentValues();
dadosParcela.put("ID_RPAPARCE", idParce);
dadosParcela.put("ID_SMAEMPRE", idEmpre);
dadosParcela.put("ID_RPAFATUR", idFatur);
dadosParcela.put("ID_CFACLIFO", idClifo);
dadosParcela.put("ID_CFATPDOC", idTpDoc);
dadosParcela.put("ID_CFATPCOB", idTpCob);
dadosParcela.put("ID_CFAPORTA", idPorta);
dadosParcela.put("DT_ALT", dtAlta);
dadosParcela.put("TIPO", tipo);
dadosParcela.put("DT_EMISSAO", dtEmissao.replace("0000-00-00", ""));
dadosParcela.put("DT_VENCIMENTO", dtVencimento.replace("0000-00-00", ""));
dadosParcela.put("DT_BAIXA", dtBaixa.replace("0000-00-00", ""));
dadosParcela.put("PARCELA", parcela);
dadosParcela.put("VL_PARCELA", vlParcela);
dadosParcela.put("FC_VL_TOTAL_PAGO", vlTotalPago);
dadosParcela.put("FC_VL_RESTANTE", vlRestante);
dadosParcela.put("VL_JUROS_DIARIO", vlJurosDiario);
dadosParcela.put("PERC_DESCONTO", percDesconto);
dadosParcela.put("SEQUENCIAL", sequencial);
dadosParcela.put("NUMERO", numero);
dadosParcela.put("OBS", obs);
final ParcelaSql parcelaSql = new ParcelaSql(context);
// Pega o sql para passar para o statement
final String sql = parcelaSql.construirSqlStatement(dadosParcela);
// Pega o argumento para o statement
final String[] argumentoSql = parcelaSql.argumentoStatement(dadosParcela);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
//parcelaSql.insertOrReplace(dadosParcela);
parcelaSql.insertOrReplaceFast(sql, argumentoSql);
}
});
} else {
parcelaSql.insertOrReplaceFast(sql, argumentoSql);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
parcelaSql.update(dadosParcela, "ID_RPAPARCE = " + idParce);
}
});
} else {
parcelaSql.update(dadosParcela, "ID_RPAPARCE = " + idParce);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
parcelaSql.delete("ID_RPAPARCE = " + idParce);
}
});
} else {
parcelaSql.delete("ID_RPAPARCE = " + idParce);
}
}
} // FIm Parcela
private void importarRegistroDtAtualizacao(String linha){
Scanner scannerDtAtualizacao = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerDtAtualizacao.next();
String dtAtualizacao = scannerDtAtualizacao.next();
scannerDtAtualizacao = null;
ContentValues dadosAtualizacao = new ContentValues();
dadosAtualizacao.put("DT_ATUALIZACAO", dtAtualizacao);
FuncoesPersonalizadas funcoes = new FuncoesPersonalizadas(context);
UsuarioSQL usuarioSQL = new UsuarioSQL(context);
// Checa se a finalidade eh atualizar
if(FINALIDADE.equalsIgnoreCase("U")){
usuarioSQL.update(dadosAtualizacao, "ID_USUA = " + funcoes.getValorXml("CodigoUsuario"));
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
usuarioSQL.delete("ID_SMAEMPRE = " + "ID_USUA = " + funcoes.getValorXml("CodigoUsuario"));
}
dadosAtualizacao = null;
}
private void importarRegistroTipoCobranca(String linha){
Scanner scannerTpCobranca = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerTpCobranca.next();
final String idTpCob = scannerTpCobranca.next();
String dtAlt = scannerTpCobranca.next();
String codigo = scannerTpCobranca.next();
String descricao = scannerTpCobranca.next();
String sigla = scannerTpCobranca.next();
scannerTpCobranca = null;
final ContentValues dadosTpCob = new ContentValues();
dadosTpCob.put("ID_CFATPCOB", idTpCob);
dadosTpCob.put("DT_ALT", dtAlt);
dadosTpCob.put("CODIGO", codigo);
dadosTpCob.put("DESCRICAO", descricao);
dadosTpCob.put("SIGLA", sigla);
final CobrancaSql cobrancaSql = new CobrancaSql(context);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
cobrancaSql.insertOrReplace(dadosTpCob);
}
});
} else {
cobrancaSql.insertOrReplace(dadosTpCob);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
cobrancaSql.update(dadosTpCob, "ID_CFATPCOB = " + idTpCob);
}
});
} else {
cobrancaSql.update(dadosTpCob, "ID_CFATPCOB = " + idTpCob);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
cobrancaSql.delete("ID_CFATPCOB = " + idTpCob);
}
});
} else {
cobrancaSql.delete("ID_CFATPCOB = " + idTpCob);
}
}
} // Fim TipoCobranca
private void importarRegistroSituacaoTributaria(String linha){
Scanner scannerSituacaoTrib = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerSituacaoTrib.next();
final String idCodSt = scannerSituacaoTrib.next();
String dtAlt = scannerSituacaoTrib.next();
String codigo = scannerSituacaoTrib.next();
String descricao = scannerSituacaoTrib.next();
String tipo = scannerSituacaoTrib.next();
String origrem = scannerSituacaoTrib.next();
scannerSituacaoTrib = null;
final ContentValues dadosSituacaoTrib = new ContentValues();
dadosSituacaoTrib.put("ID_AEACODST", idCodSt);
dadosSituacaoTrib.put("DT_ALT", dtAlt);
dadosSituacaoTrib.put("CODIGO", codigo);
dadosSituacaoTrib.put("DESCRICAO", descricao);
dadosSituacaoTrib.put("TIPO", tipo);
dadosSituacaoTrib.put("ORIGEM", origrem);
final SituacaoTributariaSql tributariaSql = new SituacaoTributariaSql(context);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
tributariaSql.insertOrReplace(dadosSituacaoTrib);
}
});
} else {
tributariaSql.insertOrReplace(dadosSituacaoTrib);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
tributariaSql.update(dadosSituacaoTrib, "ID_AEACODST = " + idCodSt);
}
});
} else {
tributariaSql.update(dadosSituacaoTrib, "ID_AEACODST = " + idCodSt);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
tributariaSql.delete("ID_AEACODST = " + idCodSt);
}
});
} else {
tributariaSql.delete("ID_AEACODST = " + idCodSt);
}
}
}
private void importarRegistroLocacao(String linha){
Scanner scannerLocacao = new Scanner(linha).useDelimiter("\\|");
String FINALIDADE = scannerLocacao.next();
final String idLoces = scannerLocacao.next();
String idEmpre = scannerLocacao.next();
String dtAlt = scannerLocacao.next();
String codigo = scannerLocacao.next();
String descricao = scannerLocacao.next();
String ativo = scannerLocacao.next();
String tipoVenda = scannerLocacao.next();
scannerLocacao = null;
final ContentValues dadosLocacao = new ContentValues();
dadosLocacao.put("ID_AEALOCES", idLoces);
dadosLocacao.put("ID_SMAEMPRE", idEmpre);
dadosLocacao.put("DT_ALT", dtAlt);
dadosLocacao.put("CODIGO", codigo);
dadosLocacao.put("DESCRICAO", descricao);
dadosLocacao.put("ATIVO", ativo);
dadosLocacao.put("TIPO_VENDA", tipoVenda);
final LocacaoSql locacaoSql = new LocacaoSql(context);
// Checa se a finalidade eh inserir
if(FINALIDADE.equalsIgnoreCase("I")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
locacaoSql.insertOrReplace(dadosLocacao);
}
});
} else {
locacaoSql.insertOrReplace(dadosLocacao);
}
// Checa se a finalidade eh atualizar
} else if(FINALIDADE.equalsIgnoreCase("U")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
locacaoSql.update(dadosLocacao, "ID_AEALOCES = " + idLoces);
}
});
} else {
locacaoSql.update(dadosLocacao, "ID_AEALOCES = " + idLoces);
}
// Checa se a finalidade eh deletar
} else if(FINALIDADE.equalsIgnoreCase("D")){
if (telaChamou != TELA_RECEPTOR_ALARME) {
((Activity) context).runOnUiThread(new Runnable() {
public void run() {
locacaoSql.delete("ID_AEALOCES = " + idLoces);
}
});
} else {
locacaoSql.delete("ID_AEALOCES = " + idLoces);
}
}
}
} | true |
2bf4705c1ecee53de9add3e853523b49ec77efe2 | Java | JetBrains/intellij-community | /plugins/testng_rt/src/com/intellij/rt/testng/IDEATestNGTestListener.java | UTF-8 | 1,255 | 1.875 | 2 | [
"Apache-2.0"
] | permissive | // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.rt.testng;
import org.testng.ITestContext;
import org.testng.ITestListener;
import org.testng.ITestResult;
public class IDEATestNGTestListener implements ITestListener {
private final IDEATestNGRemoteListener myListener;
public IDEATestNGTestListener(IDEATestNGRemoteListener listener) {
myListener = listener;
}
@Override
public void onTestStart(ITestResult result) {
myListener.onTestStart(result);
}
@Override
public void onTestSuccess(ITestResult result) {
myListener.onTestSuccess(result);
}
@Override
public void onTestFailure(ITestResult result) {
myListener.onTestFailure(result);
}
@Override
public void onTestSkipped(ITestResult result) {
myListener.onTestSkipped(result);
}
@Override
public void onTestFailedButWithinSuccessPercentage(ITestResult result) {
myListener.onTestFailedButWithinSuccessPercentage(result);
}
@Override
public void onStart(ITestContext context) {
myListener.onStart(context);
}
@Override
public void onFinish(ITestContext context) {
myListener.onFinish(context);
}
}
| true |
43150874ee9474d4364a048128c88833e5865e5d | Java | 123123ll/demos | /demo/src/main/java/com/example/demo/bytes.java | UTF-8 | 2,188 | 3.234375 | 3 | [] | no_license | package com.example.demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
/**
* @ClassName: bytetest
* @Description: ไบ่ฟๅถๅญๅจไผ ่พ
* @Author: liu
* @Date: 2021/7/13 17:11
*/
public class bytes {
public static void main(String[] args) throws IOException {
FileOutputStream file = new FileOutputStream("D://bytes//a.data",true);
int[] ints = {1,2,3,4,5,6,7,8,9};
System.out.println("tostring:"+ints.toString());
for (int i = 0; i < ints.length; i++) {
file.write(getBytes(ints[i]));
}
file.write("\n".getBytes());
file.close();
FileInputStream fileInputStream = new FileInputStream("D://bytes//a.data");
byte[] bytes = new byte[1024];
int i = 0;
if ((i = fileInputStream.read(bytes))!=-1){
byte[] b = new byte[i];
System.arraycopy(bytes,0,b,0,i);
System.out.println(Arrays.toString(bytesToInts(b)));
}
}
public static int[] bytesToInts(byte[] bytes){
int bytesLength=bytes.length;
int[] ints=new int[bytesLength%4==0? bytesLength/4:bytesLength/4+1];
int lengthFlag=4;
while (lengthFlag<=bytesLength){
ints[lengthFlag/4-1]=(bytes[lengthFlag-4]<<24)|(bytes[lengthFlag-3]&0xff)<<16|
(bytes[lengthFlag-2]&0xff)<<8|(bytes[lengthFlag-1]&0xff);
lengthFlag+=4;
}
for (int i=0;i<bytesLength+4-lengthFlag;i++){
if (i==0) ints[lengthFlag/4-1]|=bytes[lengthFlag-4+i]<<8*(bytesLength+4-lengthFlag-i-1);
else ints[lengthFlag/4-1]|=(bytes[lengthFlag-4+i]&0xff)<<8*(bytesLength+4-lengthFlag-i-1);
}
return ints;
}
/**
* ๅฐๆดๅๆฐๅผ่ฝฌๆขไธบๅญ่ๆฐ็ป
*
* @param data
* @return
*/
public static byte[] getBytes(int data) {
byte[] bytes = new byte[4];
bytes[0] = (byte) ((data & 0xff000000) >> 24);
bytes[1] = (byte) ((data & 0xff0000) >> 16);
bytes[2] = (byte) ((data & 0xff00) >> 8);
bytes[3] = (byte) (data & 0xff);
return bytes;
}
}
| true |
d255974e3b93186db17e0863ed137dbb66ef12ee | Java | Jeong-hyein/yedam2020 | /HelloWorld/src/com/yedam/jhi/classes/Student.java | UTF-8 | 2,695 | 4 | 4 | [] | no_license | package com.yedam.jhi.classes;
//๊ฐ์ฒด๋ ์๋ฐ๋ก ํํํ๋ ๋ชจ๋ ๊ฒ?
//๊ฐ์ฒด๋ฅผ ํํํ๋๊ฑฐ: class
//๋ถ์ด๋นตํ: class ๋ถ์ด๋นต:instance
//class: ํ๋, ์์ฑ์, ๋ฉ์๋๋ ์์ด์ผํ๋ค.
public class Student {
// class์ ์์ฑ์ด๊ณ ํ๋๋ผ๊ณ ํ๋ค.
// private: ๋ณด์์ ์ํด์ ์ฌ์ฉ, ์ธ๋ถ๋ก๋ถํฐ ์จ๊ธด๋ค -> ์์ฑ์or๋ฉ์๋๋ก ์ ๊ทผ
// private: get,set์ ์ฌ์ฉํ๋ ค๋ฉด ๋ถ์ธ๋ค. ํ๋๊ฐ์ ์ง์ ์ ๊ทผ ๋ชป ํ๋๋ก
private String name;
private int age;
private int height;
private int weight;
static String major;
// ์์ฑ์(์ธ์คํด์ค๋ฅผ ๋ง๋ค๋ฉด์ ํ๋๊ฐ์ ์ด๊ธฐํ)
// ๋งค๊ฐ๊ฐ์ด ์๋ ์์ฑ์๊ฐ ๊ธฐ๋ณธ ์์ฑ์, ๋ฐํ๊ฐ์ด ์๋ค
// (): ์คํํ๋ผ๋๊ฑฐ.
// ๋ค๋ฅธ ์์ฑ์๊ฐ ์๊ธด๋ค๋ฉด student()๊ฐ ๊ธฐ๋ณธ์์ฑ์๊ฐ ์๋๋ค. ์ฌ์ฉ์ ๊ฐ๋ฅ
// ์์ฑ์๊ฐ ์๋ฌด๊ฒ๋ ์์๋๋ Student(){}๊ฐ ๊ธฐ๋ณธ์ด๋ผ์ student(){}๋ฅผ ๋ฐ๋ก
// ์์จ์ค๋ ์ฌ์ฉ๊ฐ๋ฅ ํ์ง๋ง ๋ค๋ฅธ ์์ฑ์๋ฅผ ๋ง๋ค๋ฉด ๊ธฐ๋ณธ์ด ์๋๊ฒ ๋์ด์
// student(){}๋ฅผ ์จ์ค์ผ ์ฌ์ฉ๊ฐ๋ฅ
public Student() {
}
// ์์ฑ์ ์ฌ๋ฌ๊ฐ ๋ง๋ค์๋ค
// this: ํ๋๋ฅผ ์๋ ค์ค, ์์ฑ์ ์ค๋ฒ๋ก๋ฉ -> ์์ฑ์์ ์ด๋ฆ์ด ๊ฐ๋ค.
public Student(String name) { // String n -> name = n; -> this์์จ๋๋จ
this.name = name;
}
Student(String name, int age, int height, int weight) {
this.name = name;
this.age = age;
this.height = height;
this.weight = weight;
}
// class์ ๊ธฐ๋ฅ(๋์)์ด๊ณ ๋ฉ์๋๋ผ๊ณ ํ๋ค.
// ๋ฉ์๋๋ ๋ฐํ๊ฐ์ด ๋ฌด์กฐ๊ฑด ์์ด์ผํ๋ค. ๋ฐํ์ํ๋ฉด void๋ผ๋ ์์ด์ผํ๋ค
public void study() {
System.out.println("๊ณต๋ถํ๋ค.");
}
public void eat() {
System.out.println("๋ฐฅ์ ๋จน๋๋ค.");
}
void sleep() {
System.out.println("์ ์ ์๋ค.");
}
// age์ ๊ฐ์ ๋ฃ๊ธฐ์ํ ๋ฉ์๋
// ๋งค๊ฐ๊ฐ์ ๋ฐ์ age๋ฅผ ageํ๋์ ์ ์ฅํ๊ฒ ๋ค.
void setAge(int age) {
if (age >= 0)
this.age = age;
else
this.age = 0;
}
// getAge๋ age ํ๋๋ฅผ ๋งํ๋ค
int getAge() {
return age; // this์์จ๋๋จ
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", height=" + height + ", weight=" + weight + "]";
}
public void setName(String name) {
this.name = name;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
}//class
| true |
9061f71cbdcec41369d308073ca8247a9f1988c4 | Java | Allenql/appinfo_sys | /src/main/java/com/sust/appinfo/service/backend/BackendUserService.java | UTF-8 | 572 | 1.96875 | 2 | [] | no_license | package com.sust.appinfo.service.backend;
import com.sust.appinfo.pojo.BackendUser;
public interface BackendUserService {
/**
* ็จๆท็ปๅฝ
* @param userCode
* @param userPassword
* @return
*/
public BackendUser login(String userCode, String userPassword) throws Exception;
public boolean checkPassword(int id, String password);
public boolean updatePassword(int id, String newUserPassword);
public boolean doUpdateUser(int id,String devCode, String devName);
public BackendUser selectById(int id);
public int updateStatus(int status, int id);
}
| true |