blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 7 410 | content_id stringlengths 40 40 | detected_licenses listlengths 0 51 | license_type stringclasses 2
values | repo_name stringlengths 5 132 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 80 | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 5.85k 684M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 132
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 9.45M | extension stringclasses 28
values | content stringlengths 3 9.45M | authors listlengths 1 1 | author_id stringlengths 0 352 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
77eb9ef49d4c103c993337f29c2cae5abf722453 | f9f1780502d471f9586bf5d2976e24f05ef6d01f | /src/main/java/net/floodlightcontroller/hub/Hub.java | 8dc85753830d36e4b943cfdd1d8ff8b69766d91a | [
"Apache-2.0"
] | permissive | vonzhou/floodlightx | 6c7f98bb51c6173983a06be28f8936f77809f738 | 8effab5020b020b9b3e634fd6ce634f826b26672 | refs/heads/master | 2021-01-17T07:10:32.874346 | 2016-04-26T04:48:35 | 2016-04-26T04:48:35 | 25,626,476 | 1 | 0 | null | null | null | null | GB18030 | Java | false | false | 4,271 | java | package net.floodlightcontroller.hub;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import net.floodlightcontroller.core.FloodlightContext;
import net.floodlightcontroller.core.IFloodlightProviderService;
import net.floodlightcontroller.core.IOFMessageListener;
import net.floodlightcontroller.core.IOFSwitch;
import net.floodlightcontroller.core.module.FloodlightModuleContext;
import net.floodlightcontroller.core.module.FloodlightModuleException;
import net.floodlightcontroller.core.module.IFloodlightModule;
import net.floodlightcontroller.core.module.IFloodlightService;
import org.openflow.protocol.OFMessage;
import org.openflow.protocol.OFPacketIn;
import org.openflow.protocol.OFPacketOut;
import org.openflow.protocol.OFPort;
import org.openflow.protocol.OFType;
import org.openflow.protocol.action.OFAction;
import org.openflow.protocol.action.OFActionOutput;
import org.openflow.util.U16;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Hub implements IFloodlightModule, IOFMessageListener {
protected static Logger log = LoggerFactory.getLogger(Hub.class);
protected IFloodlightProviderService floodlightProvider;
/**
* @param floodlightProvider the floodlightProvider to set
*/
public void setFloodlightProvider(IFloodlightProviderService floodlightProvider) {
this.floodlightProvider = floodlightProvider;
}
@Override
public String getName() {
return Hub.class.getPackage().getName();
}
/*
* Hub的具体处理逻辑：通过packet out来广播到其他端口
*/
public Command receive(IOFSwitch sw, OFMessage msg, FloodlightContext cntx) {
// 只监听packet in 消息
OFPacketIn pi = (OFPacketIn) msg;
OFPacketOut po = (OFPacketOut) floodlightProvider.getOFMessageFactory()
.getMessage(OFType.PACKET_OUT);
po.setBufferId(pi.getBufferId())
.setInPort(pi.getInPort());
// set actions
OFActionOutput action = new OFActionOutput().setPort((short) OFPort.OFPP_FLOOD.getValue());
po.setActions(Collections.singletonList((OFAction)action));
po.setActionsLength((short) OFActionOutput.MINIMUM_LENGTH);
// set data if is is included in the packetin
if (pi.getBufferId() == 0xffffffff) {
byte[] packetData = pi.getPacketData();
po.setLength(U16.t(OFPacketOut.MINIMUM_LENGTH
+ po.getActionsLength() + packetData.length));
po.setPacketData(packetData);
} else {
po.setLength(U16.t(OFPacketOut.MINIMUM_LENGTH
+ po.getActionsLength()));
}
try {
sw.write(po, cntx);
} catch (IOException e) {
log.error("Failure writing PacketOut", e);
}
return Command.CONTINUE;
}
@Override
public boolean isCallbackOrderingPrereq(OFType type, String name) {
return false;
}
@Override
public boolean isCallbackOrderingPostreq(OFType type, String name) {
return false;
}
// IFloodlightModule
@Override
public Collection<Class<? extends IFloodlightService>> getModuleServices() {
// We don't provide any services, return null
return null;
}
@Override
public Map<Class<? extends IFloodlightService>, IFloodlightService>
getServiceImpls() {
// We don't provide any services, return null
return null;
}
@Override
public Collection<Class<? extends IFloodlightService>>
getModuleDependencies() {
Collection<Class<? extends IFloodlightService>> l =
new ArrayList<Class<? extends IFloodlightService>>();
l.add(IFloodlightProviderService.class);
return l;
}
@Override
public void init(FloodlightModuleContext context)
throws FloodlightModuleException {
floodlightProvider =
context.getServiceImpl(IFloodlightProviderService.class);
}
@Override
public void startUp(FloodlightModuleContext context) {
floodlightProvider.addOFMessageListener(OFType.PACKET_IN, this);
}
}
| [
"vonzhou@163.com"
] | vonzhou@163.com |
885ea6892a22a4f2e804b3f4680f4e38cadd04c7 | 96ff09995bf6ee4c9111fe6589af4096b9caacf7 | /Shooting/src/main/java/org/offline/shooting/LoadDataFragment.java | a6fba6c5d3035dd7ddd2d072a4a13d8b39a81c6a | [] | no_license | jonathanburchmore/Shooting | 0351be41cb001fb6e2f9d1f320d1bf6571a6add6 | d97dce3dd926efc5c1d319a4f326efe5d6b84367 | refs/heads/master | 2021-05-08T08:18:25.669366 | 2017-10-15T00:57:41 | 2017-10-15T00:57:41 | 106,972,697 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,801 | java | /*
* :vi ts=4 sts=4 sw=4
*
* Copyright (c) Jonathan Burchmore
*/
package org.offline.shooting;
import android.app.AlertDialog;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.DialogInterface;
import android.content.Intent;
import android.database.Cursor;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.LoaderManager;
import android.support.v4.content.CursorLoader;
import android.support.v4.content.Loader;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
public class LoadDataFragment extends Fragment implements LoaderManager.LoaderCallbacks<Cursor>
{
private FragmentActivity mActivity;
private ContentResolver mContentResolver;
private LoaderManager mLoaderManager;
private long mLoadId;
private TextView mTextCaliber;
private TextView mTextBullet;
private TextView mTextPowder;
private TextView mTextCharge;
private TextView mTextPrimer;
private TextView mTextOAL;
private TextView mTextCrimp;
public LoadDataFragment()
{
}
@Override
public void onCreate( Bundle savedInstanceState )
{
Bundle arguments;
super.onCreate( savedInstanceState );
mActivity = getActivity();
mContentResolver = mActivity.getContentResolver();
mLoaderManager = mActivity.getSupportLoaderManager();
arguments = getArguments();
mLoadId = arguments.getLong( ShootingApplication.PARAM_LOAD_ID );
}
@Override
public View onCreateView( LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState )
{
return inflater.inflate( R.layout.fragment_load_data, null );
}
@Override
public void onViewCreated( View view, Bundle savedInstanceState )
{
super.onViewCreated( view, savedInstanceState );
setHasOptionsMenu( true );
mTextCaliber = ( TextView ) view.findViewById( R.id.load_data_caliber );
mTextBullet = ( TextView ) view.findViewById( R.id.load_data_bullet );
mTextPowder = ( TextView ) view.findViewById( R.id.load_data_powder );
mTextCharge = ( TextView ) view.findViewById( R.id.load_data_charge );
mTextPrimer = ( TextView ) view.findViewById( R.id.load_data_primer );
mTextOAL = ( TextView ) view.findViewById( R.id.load_data_oal );
mTextCrimp = ( TextView ) view.findViewById( R.id.load_data_crimp );
mLoaderManager.initLoader( ShootingApplication.LOADER_LOAD_DATA_FRAGMENT, null, this );
}
@Override
public void onDestroy()
{
super.onDestroy();
mLoaderManager.destroyLoader( ShootingApplication.LOADER_LOAD_DATA_FRAGMENT );
}
@Override
public void onCreateOptionsMenu( Menu menu, MenuInflater inflater )
{
inflater.inflate( R.menu.fragment_load_data, menu );
menu.findItem( R.id.menu_load_data_edit ).setOnMenuItemClickListener( onEditDataClicked );
menu.findItem( R.id.menu_load_data_delete ).setOnMenuItemClickListener( onDeleteLoadClicked );
}
private final MenuItem.OnMenuItemClickListener onEditDataClicked = new MenuItem.OnMenuItemClickListener()
{
@Override
public boolean onMenuItemClick( MenuItem menuItem )
{
Intent intent;
intent = new Intent( mActivity, LoadDataActivity.class );
intent.putExtra( ShootingApplication.PARAM_LOAD_ID, mLoadId );
startActivity( intent );
return true;
}
};
private final MenuItem.OnMenuItemClickListener onDeleteLoadClicked = new MenuItem.OnMenuItemClickListener()
{
@Override
public boolean onMenuItemClick( MenuItem menuItem )
{
AlertDialog.Builder builder = new AlertDialog.Builder( mActivity );
builder.setTitle( R.string.title_load_delete );
builder.setMessage( R.string.confirm_load_delete );
builder.setNegativeButton( R.string.button_cancel, null );
builder.setPositiveButton( R.string.button_delete, new DialogInterface.OnClickListener()
{
@Override
public void onClick( DialogInterface dialogInterface, int i )
{
mContentResolver.delete( ContentUris.withAppendedId( ShootingContract.Loads.CONTENT_URI, mLoadId ), null, null );
}
} );
builder.show();
return true;
}
};
@Override
public Loader<Cursor> onCreateLoader( int i, Bundle bundle )
{
return new CursorLoader( mActivity,
ContentUris.withAppendedId( ShootingContract.Loads.CONTENT_URI, mLoadId ),
null, null, null, null );
}
@Override
public void onLoadFinished( Loader<Cursor> cursorLoader, Cursor cursor )
{
String primer;
if ( !cursor.moveToFirst() )
{
return;
}
mTextCaliber.setText( cursor.getString( cursor.getColumnIndex( ShootingContract.Loads.CALIBER ) ) );
mTextBullet.setText( cursor.getString( cursor.getColumnIndex( ShootingContract.Loads.BULLET ) ) );
mTextPowder.setText( cursor.getString( cursor.getColumnIndex( ShootingContract.Loads.POWDER ) ) );
mTextCharge.setText( cursor.getString( cursor.getColumnIndex( ShootingContract.Loads.CHARGE ) ) );
mTextOAL.setText( cursor.getString( cursor.getColumnIndex( ShootingContract.Loads.OAL ) ) );
mTextCrimp.setText( cursor.getString( cursor.getColumnIndex( ShootingContract.Loads.CRIMP ) ) );
mTextCaliber.setHint( "" );
mTextBullet.setHint( "" );
mTextPowder.setHint( "" );
mTextCharge.setHint( "" );
mTextOAL.setHint( "" );
mTextCrimp.setHint( "" );
if ( ( primer = cursor.getString( cursor.getColumnIndex( ShootingContract.Loads.PRIMER ) ) ) == null )
{
mTextPrimer.setText( "" );
mTextPrimer.setHint( getString( R.string.hint_unspecified ) );
}
else
{
mTextPrimer.setText( primer );
mTextPrimer.setHint( "" );
}
}
@Override
public void onLoaderReset( Loader<Cursor> cursorLoader )
{
}
}
| [
"jonathanburchmore@gmail.com"
] | jonathanburchmore@gmail.com |
e770bca78e352b7d07bfc9789618ec769b827c75 | e0c9e7b4ca827cfe37bbb135466e05fa5d35fe77 | /src/main/java/com/project/manager/config/WebAppInitializer.java | 2f94f2a254d318e1699ad34052a6b0409a7e1e12 | [] | no_license | Sagar-deshmukh/project-manager | 90338845221f8eb0c63f93162d0af0baa5ecc9f4 | f111db29f1de988f504bcd03535e1f72368c3b93 | refs/heads/master | 2020-03-31T09:13:32.120279 | 2018-11-01T08:46:01 | 2018-11-01T08:46:01 | 152,086,951 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 909 | java | package com.project.manager.config;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
public class WebAppInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext container) throws ServletException {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(WebMvcConfig.class);
ctx.setServletContext(container);
ServletRegistration.Dynamic servlet = container.addServlet("mvc", new DispatcherServlet(ctx));
servlet.setLoadOnStartup(1);
servlet.addMapping("/*");
}
}
| [
"sagar.deshmukh3@cognizant.com"
] | sagar.deshmukh3@cognizant.com |
952ef3cfa5c7f8f1915b2ba2849dd2b0be1ae3fa | d64582aa2a32cc0e274bc1422b4e3621c2f91736 | /lab-api/src/main/java/ac/cn/saya/lab/api/service/medium/PictureStorageService.java | 66a3df4f63b5fbc9b390a84bf5c65904a16fdab9 | [
"Apache-2.0"
] | permissive | saya-ac-cn/lab | 6ef59e4263774ed88aa6fb59241c42b20c6c5361 | 034ef9c80b7d2f6462a7c352c351c00bb99e784c | refs/heads/master | 2022-07-04T12:24:19.206621 | 2020-08-26T14:41:14 | 2020-08-26T14:41:14 | 234,917,318 | 0 | 0 | Apache-2.0 | 2022-06-21T02:54:45 | 2020-01-19T14:58:16 | Java | UTF-8 | Java | false | false | 1,667 | java | package ac.cn.saya.lab.api.service.medium;
import ac.cn.saya.lab.api.entity.PictureEntity;
import ac.cn.saya.lab.api.tools.Result;
/**
* @Title: PictureStorageService
* @ProjectName lab
* @Description: TODO
* @Author liunengkai
* @Date: 2020-03-13 20:41
* @Description:
*/
public interface PictureStorageService {
/**
* @描述 图片上传服务（Base64）
* @参数 [entity]
* @返回值 java.lang.Integer
* @创建人 saya.ac.cn-刘能凯
* @创建时间 2020/3/13
* @修改人和其它信息
*/
public Result<Integer> uploadPictureBase64(PictureEntity entity);
/**
* @描述 删除base64类型的图片
* @参数
* @返回值
* @创建人 saya.ac.cn-刘能凯
* @创建时间 2020/3/13
* @修改人和其它信息
*/
public Result<Integer> deletePictuBase64(PictureEntity entity);
/**
* @描述 查询分页后的图片
* @参数
* @返回值
* @创建人 saya.ac.cn-刘能凯
* @创建时间 2020/3/13
* @修改人和其它信息
*/
public Result<Object> getPictuBase64Page(PictureEntity entity);
/**
* @描述 查询一张图片
* @参数
* @返回值
* @创建人 saya.ac.cn-刘能凯
* @创建时间 2020/3/13
* @修改人和其它信息
*/
public Result<PictureEntity> getOnePictuBase64(PictureEntity entity);
/**
* @描述 查询图片的总数
* @参数
* @返回值
* @创建人 saya.ac.cn-刘能凯
* @创建时间 2019/1/12
* @修改人和其它信息
*/
public Result<Long> getPictuBase64Count(PictureEntity entity);
}
| [
"saya@saya.ac.cn"
] | saya@saya.ac.cn |
9df7fbbb9beb8530b791aeca74e20cbe6c1135d5 | 40ce712aba62c8201cf46e70d48c8e9981a557c7 | /ROOT/WEB-INF/src/booking/po/Booking.java | 381886a073a4277b36b7e348f861719e43a0cb1f | [] | no_license | BiRii/Booking | 1f3d4c50f73516a0d9eb631dff8089fb63cb78cb | 08964af3f98d54dee7a69599024b64f46645d14f | refs/heads/master | 2020-09-05T13:07:41.902691 | 2020-03-23T08:30:42 | 2020-03-23T08:30:42 | 220,114,715 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,100 | java | package booking.po;
import java.sql.Date;
public class Booking
{
//预订类的标识属性
private Long bookId;
//预订场地名称
private String bookField;
//预订日期
private Date bookDate;
//预订场地号
private String bookFieldNo;
//预订时间
private String bookTime;
//预订用户
private String bookUser;
//预订提交的时间
private String submitTime;
//无参数的构造器
public Booking()
{}
//初始化全部基本属性的构造器
public Booking(Long bookId, String bookField, Date bookDate, String bookFieldNo, String bookTime, String bookUser, String submitTime)
{
this.bookId = bookId;
this.bookField = bookField;
this.bookDate = bookDate;
this.bookFieldNo = bookFieldNo;
this.bookTime = bookTime;
this.bookUser = bookUser;
this.submitTime = submitTime;
}
//bookId属性的setter和getter方法
public void setBookId(Long bookId)
{
this.bookId = bookId;
}
public Long getBookId()
{
return this.bookId;
}
//bookField属性的setter和getter方法
public void setBookField(String bookField)
{
this.bookField = bookField;
}
public String getBookField()
{
return this.bookField;
}
//bookDate属性的setter和getter方法
public void setBookDate(Date bookDate)
{
this.bookDate = bookDate;
}
public Date getBookDate()
{
return this.bookDate;
}
//bookFieldNo属性的setter和getter方法
public void setBookFieldNo(String bookFieldNo)
{
this.bookFieldNo = bookFieldNo;
}
public String getBookFieldNo()
{
return this.bookFieldNo;
}
//bookTime属性的setter和getter方法
public void setBookTime(String bookTime)
{
this.bookTime = bookTime;
}
public String getBookTime()
{
return this.bookTime;
}
//bookUser属性的setter和getter方法
public void setBookUser(String bookUser)
{
this.bookUser = bookUser;
}
public String getBookUser()
{
return this.bookUser;
}
//submitTime属性的setter和getter方法
public void setSubmitTime(String submitTime)
{
this.submitTime = submitTime;
}
public String getSubmitTime()
{
return this.submitTime;
}
} | [
"56522331+BiRii@users.noreply.github.com"
] | 56522331+BiRii@users.noreply.github.com |
69fbbf738079811d624177d6fcdff53110e81dde | 76fa4b68dc45d41abf028a57bb4ca538c3958fbf | /src/main/java/jsf/bean/crud/UserCrudBean.java | a134c2b2849c977dba4ebb2f30d6d061df11dbef | [] | no_license | Lrakulka/Lux_JavaEE_FinalProject | 7a42bf12e70bc5d5b6e9b110aa1c63a5ea076f39 | c64b70d9dafc3c7121f82a5a1adce4a47e53eea7 | refs/heads/master | 2020-06-13T05:54:58.419974 | 2017-01-05T22:20:35 | 2017-01-05T22:20:35 | 75,422,359 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,180 | java | package jsf.bean.crud;
import ejb.entity.User;
import ejb.facade.AbstractDBObjectFacade;
import ejb.facade.UserFacade;
import jsf.bean.model.SessionData;
import javax.enterprise.context.Conversation;
import javax.enterprise.context.ConversationScoped;
import javax.inject.Inject;
import javax.inject.Named;
/**
* Created by Schuller Tom
* Modified by Oleksandr Borysov
* I added logout of user if he delete himself
*/
@Named
@ConversationScoped
public class UserCrudBean extends AbstractDBObjectCrudBean<User> {
@Inject
private Conversation conversation;
@Inject
private UserFacade facade;
@Inject
private SessionData sessionData;
// If user delete himself - System make him logout
@Override
public String doDelete() {
if (entity.equals(sessionData.getLoggedUser())) {
sessionData.setLoggedUser(null);
}
return super.doDelete();
}
@Override
public Class getClazz() {
return User.class;
}
@Override
public Conversation getConversation() {
return conversation;
}
@Override
public AbstractDBObjectFacade getFacade() {
return facade;
}
} | [
"olecsandr32@gmail.com"
] | olecsandr32@gmail.com |
c30236083e411f5675dd6b680b54f71e0ead164b | e6ac264001cc762a12470efe031587658839e7d7 | /ClimbContest/src/main/java/cc/service/slb/SlbScore.java | ef8325d04607c3fb28e00989a50e27d0f2d6a4b7 | [] | no_license | PioMie/climb-contest | 8be475070803a533dd6781067fc8169e69369d64 | 8dff54974ce5352614889182bb293f00932e4539 | refs/heads/master | 2020-03-26T01:55:29.188930 | 2020-02-18T19:54:58 | 2020-02-18T19:54:58 | 144,388,538 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,599 | java | package cc.service.slb;
import java.util.Comparator;
import java.util.Objects;
import org.springframework.util.StringUtils;
public class SlbScore implements Comparable<SlbScore> {
public static SlbScore parseString(String slbScoreString) {
if (StringUtils.isEmpty(slbScoreString)) {
return new SlbScore(0, 0);
}
String[] parts = slbScoreString.split("t|b");
if (parts.length != 2) {
throw new RuntimeException(
String.format("Parsing of a score: '%s' has failed: wrong number of arguments."));
}
int tops = Integer.parseInt(parts[0]);
int bonuses = Integer.parseInt(parts[1]);
return new SlbScore(tops, bonuses);
}
int bonuses;
int tops;
public SlbScore() {
// default constructor: 0, 0, 0, 0
}
public SlbScore(int tops, int bonuses) {
this.tops = tops;
this.bonuses = bonuses;
}
@Override
public int compareTo(SlbScore o) {
return Comparator.comparing(SlbScore::getTops).thenComparing(SlbScore::getBonuses).compare(this, o);
}
@Override
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof SlbScore)) {
return false;
}
SlbScore slbScore = (SlbScore) o;
return tops == slbScore.tops && bonuses == slbScore.bonuses;
}
public int getBonuses() {
return bonuses;
}
public String getScore() {
return toString();
}
public int getTops() {
return tops;
}
@Override
public int hashCode() {
return Objects.hash(tops, bonuses);
}
@Override
public String toString() {
return tops + "t" + bonuses + "b";
}
}
| [
"piotr.mierzejewski@sap.com"
] | piotr.mierzejewski@sap.com |
c144544db9da3544458269ae0fb2ae3a528df671 | e49ddf6e23535806c59ea175b2f7aa4f1fb7b585 | /branches/scripting/mipav/src/plugins/PlugInAlgorithmRemoveBlinks.java | 241cafe83f11879a24f014916bba6c4ca4ba3d05 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | svn2github/mipav | ebf07acb6096dff8c7eb4714cdfb7ba1dcace76f | eb76cf7dc633d10f92a62a595e4ba12a5023d922 | refs/heads/master | 2023-09-03T12:21:28.568695 | 2019-01-18T23:13:53 | 2019-01-18T23:13:53 | 130,295,718 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 8,434 | java | import gov.nih.mipav.model.algorithms.*;
import gov.nih.mipav.model.algorithms.utilities.*;
import gov.nih.mipav.model.structures.*;
import gov.nih.mipav.view.dialogs.*;
import gov.nih.mipav.view.ViewJFrameMessage;
import gov.nih.mipav.plugins.*;
import java.io.*;
import gov.nih.mipav.view.ViewUserInterface;
import java.awt.Frame;
public class PlugInAlgorithmRemoveBlinks
extends AlgorithmBase {
private double[] buffer = null;
private double[] averages = null;
private double[] sliceMax = null;
private boolean[] removedSlices = null;
private double thresholdDevsNorm = .6; // # of std deviations to allow for slices with a normal max
private double thresholdMax;
private double percentage = 80;
private boolean calcInPlace = false;
private boolean doRemove = true;
/**
* @param destImg image model where result image is to stored
* @param srcImage source image model
*/
public PlugInAlgorithmRemoveBlinks(ModelImage srcImg, boolean doRemove) {
this.srcImage = srcImg;
this.doRemove = doRemove;
}
/**
* Prepares this class for destruction
*/
public void finalize() {
destImage = null;
srcImage = null;
super.finalize();
}
/**
* Constructs a string of the contruction parameters and out puts the
* string to the messsage frame if the logging procedure is turned on.
*/
private void constructLog() {
historyString = new String("RemoveBlinks()\n");
}
/**
* Starts the program
*/
public void runAlgorithm() {
constructLog();
removeBlinks();
}
public boolean [] getBlinks() {
return this.removedSlices;
}
private void removeBlinks() {
int xDim, yDim;
int numSlices;
int length;
int i, j;
xDim = srcImage.getExtents()[0];
yDim = srcImage.getExtents()[1];
numSlices = srcImage.getExtents()[2];
thresholdMax = ( (double) (percentage) / 100.0) * srcImage.getMax();
float totalAverage = 0;
try {
length = xDim * yDim;
buffer = new double[length];
averages = new double[numSlices];
sliceMax = new double[numSlices];
removedSlices = new boolean[numSlices];
buildProgressBar(srcImage.getImageName(), "Locating blinks ...", 0, 100);
}
catch (OutOfMemoryError e) {
buffer = null;
System.gc();
displayError("Algorithm Blink Removal reports: Out of memory when creating image buffer");
setCompleted(false);
return;
}
initProgressBar();
double mod = 100.0 / numSlices;
int counter = 0;
// export each slice into buffer and calculate the intensities
for (i = 0; i < numSlices; i++) {
try {
srcImage.exportSliceXY(i, buffer);
sliceMax[i] = buffer[0];
for (j = 0; j < length; j++) {
averages[i] += buffer[j];
if (buffer[j] > sliceMax[i]) {
sliceMax[i] = buffer[j];
}
}
averages[i] /= length;
progressBar.updateValue((int)((i+1) * mod));
}
catch (IOException ex) {
System.err.println(ex.toString());
}
counter += length;
totalAverage += averages[i];
}
//get the total average
totalAverage /= numSlices;
//find the sum of squares
double sumOfSquares = 0;
double deviation = 0;
for (i = 0; i < numSlices; i++) {
deviation = averages[i] - totalAverage;
sumOfSquares += (deviation * deviation);
counter++;
}
double standardDeviation = Math.sqrt(sumOfSquares / (numSlices - 1));
int numNewSlices = 0;
int numRemovedSlices = 0;
boolean hitThreshold = false;
for (i = 0; i < numSlices; i++) {
counter++;
//threshold has not been hit
if (!hitThreshold) {
// average is still below threshold
if (averages[i] < totalAverage * .75) {
// if the slice max intensity is less than 50.. discard
if (sliceMax[i] < thresholdMax) {
removedSlices[i] = true;
numRemovedSlices++;
}
else {
removedSlices[i] = false;
}
}
//average is above threshold
else {
hitThreshold = true;
removedSlices[i] = false;
}
}
//threshold has been hit... will now use std deviation
else {
deviation = totalAverage - averages[i];
//System.err.println((i + 1) + "Standard deviation (average): " + (deviation - standardDeviation));
if ( (deviation - standardDeviation) > thresholdDevsNorm) {
removedSlices[i] = true;
numRemovedSlices++;
//System.err.println("Removing slice: " + (i + 1) + " Std devs away: " + (deviation - standardDeviation));
}
else {
removedSlices[i] = false;
}
}
}
numNewSlices = numSlices - numRemovedSlices;
System.err.println("Found " + numRemovedSlices + " blinks in " + srcImage.getImageFileName());
ViewUserInterface.getReference().getMessageFrame().append("\tfound " + numRemovedSlices + " blinks in " + srcImage.getImageFileName() + "\n",
ViewJFrameMessage.DATA);
for (j = 0; j < removedSlices.length; j++) {
if (removedSlices[j]) {
ViewUserInterface.getReference().getMessageFrame().append("\t" + (j + 1) + ": blink detected\n", ViewJFrameMessage.DATA);
}
}
disposeProgressBar();
if (doRemove) {
//determine the extents for the new movie
System.err.println("Removing " + numRemovedSlices + " slices. Result image has " + numNewSlices + " slices");
if (numRemovedSlices > 0 && numNewSlices > 0) {
if (!calcInPlace) {
int[] extents = new int[3];
extents[0] = srcImage.getExtents()[0];
extents[1] = srcImage.getExtents()[1];
extents[2] = numNewSlices;
String name = JDialogBase.makeImageName(srcImage.getImageName(),
"_no_blinks");
destImage = new ModelImage(srcImage.getType(), extents, name);
}
AlgorithmRemoveSlices algoRS = new AlgorithmRemoveSlices(srcImage,
destImage, removedSlices);
// algoRS.setActiveImage(activeImage);
algoRS.run();
if (algoRS.isCompleted()) {
setCompleted(true);
return;
} else {
setCompleted(false);
return;
}
} else {
if (numRemovedSlices == 0) {
System.err.println("Algorithm will remove no slices");
} else {
System.err.println("Algorithm would remove all slices: aborting");
}
//because this can be used in a script, will just clone the image as the result
String name = JDialogBase.makeImageName(srcImage.getImageName(),
"_unchanged");
destImage = new ModelImage(srcImage.getType(), srcImage.getExtents(),
name);
}
}
setCompleted(true);
notifyListeners(this);
}
public ModelImage getResultImage() {
return destImage;
}
}
| [
"NIH\\mccreedy@ba61647d-9d00-f842-95cd-605cb4296b96"
] | NIH\mccreedy@ba61647d-9d00-f842-95cd-605cb4296b96 |
fac7841cfdf2f949d1ce7629202810f0e20877c1 | a7376b4d5e223ac154a34fde517a6f86ca52516c | /statements/module-statements/src/main/java/domain/statements/dom/srv/cfg/StatementReaderService.java | 46d637d64f573d7366c5fcda7ae930e6e4e06b4b | [] | no_license | Jayeshecs/tools | 20b6c2e070c03bc0cb515d0b504e704e22f46de1 | 377089454b32f560c2da5449b57536dc86d522a2 | refs/heads/master | 2021-04-03T09:36:56.250906 | 2019-05-09T16:45:01 | 2019-05-09T16:45:01 | 125,212,687 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 2,485 | java | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package domain.statements.dom.srv.cfg;
import javax.jdo.JDOQLTypedQuery;
import org.apache.isis.applib.annotation.Action;
import org.apache.isis.applib.annotation.DomainService;
import org.apache.isis.applib.annotation.NatureOfService;
import org.apache.isis.applib.annotation.Programmatic;
import org.apache.isis.applib.events.domain.ActionDomainEvent;
import domain.statements.dom.impl.cfg.QStatementReader;
import domain.statements.dom.impl.cfg.ReaderType;
import domain.statements.dom.impl.cfg.StatementReader;
import domain.statements.dom.srv.AbstractEntityService;
@DomainService(
nature = NatureOfService.DOMAIN,
objectType = "statements.StatementReaderService",
repositoryFor = StatementReader.class
)
public class StatementReaderService extends AbstractEntityService<StatementReader> {
@SuppressWarnings("serial")
public static class CreateDomainEvent extends ActionDomainEvent<StatementReaderService> {}
@Action(domainEvent = CreateDomainEvent.class)
public StatementReader create(final String name, final ReaderType readerType) {
return repositoryService.persist(new StatementReader(name, readerType));
}
@Programmatic
public StatementReader findByNameExact(String name) {
JDOQLTypedQuery<StatementReader> q = isisJdoSupport.getJdoPersistenceManager().newJDOQLTypedQuery(StatementReader.class);
final QStatementReader cand = QStatementReader.candidate();
q = q.filter(cand.name.eq(q.stringParameter("name"))
);
return q.setParameter("name", name)
.executeUnique();
}
}
| [
"jayesh.prajapati@smartstream-stp.com"
] | jayesh.prajapati@smartstream-stp.com |
1fdcc171d94718a0b728b87b26a188f3fdc64984 | b5fab4fa2e8be3d217c372cf6484e4ff398fa744 | /src/servidor/Servidor.java | 5d54ebba40b3ca66dfb976e414e17f1dddc996a5 | [] | no_license | Jose-Claudivan/Chat_Cliente_Servidor | cb922826bca41bfbc500084d01b96934299c6a0a | bba1bd53238a0d8e9e95e435aceb83865e68f8bc | refs/heads/master | 2021-03-28T06:43:21.248417 | 2020-05-12T16:36:48 | 2020-05-12T16:36:48 | 247,847,614 | 1 | 0 | null | 2020-03-21T00:16:51 | 2020-03-17T00:54:53 | Java | UTF-8 | Java | false | false | 7,249 | java | ////////////////////////////////////////////////////////////////////////////////
/// ///
/// UNIFAVIP WYDEN ///
/// Professor: Jadson ///
/// Disciplina: Programação de Serviços de Rede ///
/// Curso: Ciência da Computação ///
/// Aluno: José Claudivan da Silva ///
/// Matricula: 181096479 ///
/// Projeto: Chat ///
/// ///
////////////////////////////////////////////////////////////////////////////////
package servidor;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.ArrayList;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
/**
*
* @author Claudivan
*/
//public class Servidor extends Thread implements Runnable {
public class Servidor {
public static void main(String args[]) {
/***********************************/
String clientSentence;
// String capitalized;
// instancia o vetor de clientes conectados
// clientes = new Vector();
try {
/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
JLabel lblMessage = new JLabel("PORTA DO SERVIDOR: ");
JTextField txtPorta = new JTextField("12345");
Object[] texts = {lblMessage, txtPorta};
JOptionPane.showMessageDialog(null, texts);
// criando um socket que fica escutando a porta 9090
ServerSocket s = new ServerSocket(12345);
System.out.println("Porta 12345 aberta!");
// Loop principal.
while (true) {
// aguarda algum cliente se conectar. A execução do
// servidor fica bloqueada na chamada do método accept da
// classe ServerSocket. Quando algum cliente se conectar
// ao servidor, o método desbloqueia e retorna com um
// objeto da classe Socket, que é porta da comunicação.
System.out.print("Esperando alguem se conectar...\n");
Socket conexao = s.accept();
//conexao.getInetAddress().getHostAddress();
System.out.println(conexao.getInetAddress().getHostAddress()+" Se conectou!");
////////////
Scanner scan = new Scanner(conexao.getInputStream());
while(scan.hasNextLine()){
System.out.println(scan.nextLine());
/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
BufferedReader inFromClient = new BufferedReader(
new InputStreamReader(conexao.getInputStream()));
/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
BufferedReader inFromUsuario = new BufferedReader(
new InputStreamReader(System.in));
/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
DataOutputStream outToClient = new DataOutputStream(
conexao.getOutputStream());
/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
BufferedReader inFromCliente = new BufferedReader(
new InputStreamReader(conexao.getInputStream()));
/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
clientSentence = inFromUsuario.readLine();
/*xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
//imprime mensagem do servidor no cliente
outToClient.writeBytes(clientSentence + "\n");
//outToClient.writeBytes(clientSentence);
System.out.print("Cliente -> ");
}
// cria uma nova thread para tratar essa conexão
// Thread t = new Servidor(conexao);
//t.start();
// voltando ao loop, esperando mais alguém se conectar.
}
}
catch (IOException e) {
// caso ocorra alguma excessão de E/S, mostre qual foi.
System.out.println("IOException: " + e);
}
}
// Parte que controla as conexões por meio de threads.
// Note que a instanciação está no main.
//private static Vector clientes;
// socket deste cliente
//private Socket conexao;
// nome deste cliente
//private String meuNome;
// construtor que recebe o socket deste cliente
//public Servidor(Socket s) {
// conexao = s;
//}
// execução da thread
// @Override
/*public void run() {
try {
// objetos que permitem controlar fluxo de comunicação
BufferedReader entrada = new BufferedReader
(new InputStreamReader(conexao.getInputStream()));
//PrintStream saida = new
//PrintStream(conexao.getOutputStream());
/***********************************
/* String li;
while(true){
li = entrada.readLine();
if (li == null){
System.out.println("COnexao encerrada, nome do usuario");
break;
}
}
// primeiramente, espera-se pelo nome do cliente
// agora, verifica se string recebida é valida, pois
// sem a conexão foi interrompida, a string é null.
// Se isso ocorrer, deve-se terminar a execução.
// Uma vez que se tem um cliente conectado e conhecido,
// coloca-se fluxo de saída para esse cliente no vetor de
// clientes conectados.
//clientes.add(saida);
// clientes é objeto compartilhado por várias threads!
// De acordo com o manual da API, os métodos são
// sincronizados. Portanto, não há problemas de acessos
// simultâneos.
// Loop principal: esperando por alguma string do cliente.
// Quando recebe, envia a todos os conectados até que o
// cliente envie linha em branco.
// Verificar se linha é null (conexão interrompida)
// Se não for nula, pode-se compará-la com métodos string
// Uma vez que o cliente enviou linha em branco, retira-se
// fluxo de saída do vetor de clientes e fecha-se conexão.
//conexao.close();
//}
catch (IOException e) {
// Caso ocorra alguma excessão de E/S, mostre qual foi.
System.out.println("IOException: " + e);
}
}*/
} | [
"claudivan0103@gmail.com"
] | claudivan0103@gmail.com |
6799d9db01be8319d90cf67233dbea63c76a44ef | bb24f13836c2464c37ffc4f8936926cee70f8bf8 | /domain/src/test/java/kan10/service/ProfileServiceTest.java | 2a192a86e179b091993686484b616ef12adae496 | [] | no_license | IliesFaddaoui/projet-synthese-ing2 | d42a15aa3e35bd846ce0859858d5c3f38dc741fb | 54db51637a6732a0ee27d51e5fb8ea73aa06876f | refs/heads/master | 2022-09-17T10:02:02.637694 | 2020-03-07T14:51:13 | 2020-03-07T14:51:13 | 245,650,681 | 0 | 0 | null | 2022-02-16T01:05:55 | 2020-03-07T14:48:14 | CSS | UTF-8 | Java | false | false | 2,961 | java | package kan10.service;
import kan10.dao.ProfileDao;
import kan10.entities.ProductCategory;
import kan10.entities.Profile;
import kan10.enums.Keywords;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ProfileServiceTest {
@Mock
private ProfileDao profileDao;
@InjectMocks
private ProfileService profileService;
private List<ProductCategory> productCategories;
@Before
public void init() {
ProductCategory productCategory1 = new ProductCategory("name1","description1");
productCategory1.setKeywords(Keywords.getDistinct(new Random().nextInt(5)));
ProductCategory productCategory2 = new ProductCategory("name2","description2");
productCategory2.setKeywords(Keywords.getDistinct(new Random().nextInt(5)));
productCategories = new ArrayList<ProductCategory>(){{
add(productCategory1);
add(productCategory2);
}};
}
@Test
public void testCreateProfile_OK() {
Profile profile = new Profile(productCategories);
List<Profile> profileList = spy(new ArrayList<>());
when(profileDao.save(profile)).thenAnswer((i) -> {
profile.setId(1L);
profileList.add(profile);
return profile;
});
when(profileDao.findAll()).thenReturn(profileList);
profileService.createProfile(profile);
List<Profile> profiles = profileService.getAllProfiles();
assertEquals(1, profiles.size());
Profile actual = profiles.get(0);
assertEquals(new Long(1), actual.getId());
assertEquals("nam_nam", actual.getLabel());
assertEquals("name1 & name2", actual.getDescription());
assertEquals(productCategories, actual.getProductCategories());
}
@Test
public void testGetAllProfiles_OK() {
List<Profile> profileList = new ArrayList<Profile>(){{
add(new Profile(productCategories));
add(new Profile(productCategories));
add(new Profile(productCategories));
add(new Profile(productCategories));
add(new Profile(productCategories));
}};
when(profileDao.findAll()).thenReturn(profileList);
List<Profile> profiles = profileService.getAllProfiles();
assertEquals(5, profiles.size());
profiles.forEach(profile -> {
assertEquals("nam_nam", profile.getLabel());
assertEquals("name1 & name2", profile.getDescription());
assertEquals(productCategories, profile.getProductCategories());
});
}
} | [
"ilies.faddaoui@gmail.com"
] | ilies.faddaoui@gmail.com |
1eb74b59590c34210b2d7919e729388e69b5a077 | 047f43d043aec6bc1ef428210ae2872bbb58ce56 | /core/src/main/java/com/excilys/formation/java/computerdb/model/Company.java | f3f418af245dacb7332764744cf49ad2766ec718 | [] | no_license | ccedric/computer-database | b11aa69c5dc2c42f7cbbcf6e2010242553234c36 | 58adbbeaa99dba64564a3fa810d40611d322bcee | refs/heads/master | 2020-04-09T04:13:48.929038 | 2016-05-06T07:32:28 | 2016-05-06T07:32:28 | 51,159,296 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,963 | java | package com.excilys.formation.java.computerdb.model;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
/**
* A company is represented by an id, and a name.
*
* @author Cédric Cousseran
*
*/
@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
@Table(name = "company")
public class Company implements Serializable {
private static final long serialVersionUID = -3683911426530599840L;
/**
* id of the company.
*/
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;
/**
* name of the company.
*/
private String name;
public Company() {
}
public Company(long id, String name) {
this.id = id;
this.name = name;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Company n°" + this.id + " de nom " + this.name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (int)id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
Company other = (Company) obj;
if (id != other.id) {
return false;
}
if (name == null) {
if (other.name != null) {
return false;
}
} else if (!name.equals(other.name)) {
return false;
}
return true;
}
}
| [
"cedric.cousseran@gmail.com"
] | cedric.cousseran@gmail.com |
3be6abab4e1c5d6ee81a39c127974180ca5f422f | 4d6f98f8b5ceb3516040d7bec4c1d35ce67c8627 | /app/src/main/java/com/ehabhamdy/ribbit/SignUpActivity.java | 332a32d1e5b8e4a206c5a0b5ad7b8c2c25bd2832 | [] | no_license | ehabhamdy/Ribbit | 00e458cb1038e0d123ce2443ee43b68d387c3605 | 9c0d0950270da210147eb3a14a55e7d63c44f88b | refs/heads/master | 2016-09-01T19:07:33.329386 | 2014-07-25T21:32:39 | 2014-07-25T21:32:39 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,044 | java | package com.ehabhamdy.ribbit;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
public class SignUpActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_sign_up);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.sign_up, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
| [
"ehabhamdy@Ehabs-Macbook-Pro.local"
] | ehabhamdy@Ehabs-Macbook-Pro.local |
94295fb73367151f17dfd8470d8cc661b3056b7b | 3079e47ba44969798af4f9294c580fe29305d1ff | /app/models/Warehouse.java | cd3a57d774767d7dc1bdce09d76362855ca1593e | [
"Apache-2.0"
] | permissive | kcanida/Warehouse | 02bebd80d66b805fd96db075e9336200f1725eea | 5ed2a4b53258146643d7327f91eab4bb22591faa | refs/heads/master | 2021-01-20T02:16:02.775101 | 2013-04-19T10:49:53 | 2013-04-19T10:49:53 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,127 | java | package models;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import play.data.validation.Constraints.Required;
import play.db.ebean.Model;
/**
*
* @author Kellie Canida
*
* A Warehouse has a single address and can hold multiple stock items.
*
*/
@Entity
public class Warehouse extends Model{
private static final long serialVersionUID = 1597818328908114668L;
@Id
private long primaryKey;
@Required
@Column(unique=true, nullable=false)
private String warehouseId;
@Required
private String name;
@OneToMany(mappedBy="warehouse", cascade=CascadeType.ALL)
private List<StockItem> stockitems = new ArrayList<>();
@OneToOne(mappedBy="warehouse", cascade=CascadeType.ALL)
private Address address;
/**
* Constructor method for a warehouse.
* @param name of warehouse.
*/
public Warehouse(String warehouseId, String name) {
this.warehouseId = warehouseId;
this.name = name;
}
public long getPrimaryKey() {
return this.primaryKey;
}
public void setPrimaryKey(long primaryKey) {
this.primaryKey = primaryKey;
}
public String getWarehouseId() {
return this.warehouseId;
}
public void setWarehouseId(String warehouseId) {
this.warehouseId = warehouseId;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public List<StockItem> getStockItems() {
return this.stockitems;
}
public void setStockItems(List<StockItem> stockItems) {
this.stockitems = stockItems;
}
public Address getAddress() {
return this.address;
}
public void setAddress(Address address) {
this.address = address;
}
public static Finder<Long,Warehouse> find() {
return new Finder<Long,Warehouse>(Long.class,Warehouse.class);
}
public String toString() {
return String.format("[Warehouse %s %s]", warehouseId, name);
}
}
| [
"kelliecanida@hotmail.com"
] | kelliecanida@hotmail.com |
647eabce2f5537dacdf1539ab58a5b0eab50e5f9 | e1d3f73bccd8fe9c492386ea201d55c7e334e2ba | /src/view/telasconta/TelaExcluiConta.java | 80fc827d0dbbfdbef467f3efff48b325a1c52fb5 | [] | no_license | nathalyamaral/Agencia_Bancaria | 29608d0f871db4580a9fe7bdc710a10d16bea59a | 8ed6f7df6f40c04ded1d3397f05a930d6fa4dffa | refs/heads/master | 2020-03-22T01:29:55.961005 | 2018-07-01T06:32:12 | 2018-07-01T06:32:12 | 139,309,077 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,472 | java | package view.telasconta;
import controller.ContaDAO;
import controller.Controller;
import controller.PessoaDAO;
import model.Conta;
import view.ClearConsole;
import view.EntradaDeDados;
import view.TratamentodeEntradas;
import view.telaspessoa.MenuExcluirConta;
/**
* A classe TelaExcluiConta e responsavel por disponibilizar a visualizacao do
* menu referente a exclusao de uma conta, utilizando de seus metodos para
* acessar as informacoes e outros metodos necessarios que estao em outras
* classes presentes no Controller, Model e em outras Views.
*
* @author Adler Cavalcante
* @author Joao Gabriel
* @author Joao Victor
* @author Michael Douglas
*
*/
public class TelaExcluiConta {
/**
* O metodo menuExcluirConta utiliza primeiramente de uma identificacao de
* pessoa, para confirmacao da identidade, impossibilitando que uma conta seja
* excluida erroneamente. Apos a validacao, o menu e imprimido para a
* visualizacao mostrando as opcoes disponiveis, no caso, sim ou nao, para a
* confirmacao da exclusao. Caso a conta exista, ela sera excluida, caso
* contrario, uma mensagem de conta nao encontrada sera emitida, assim como
* mensagens de erro para se o usuario digitar uma opcao invalida alem das
* possiveis, ou se alguma informacao da identidade for invalida.
*/
public static void menuExcluirConta() {
int opcao;
boolean sair = false;
Conta conta;
do {
try {
new ClearConsole();
System.out.println();
System.out.println("\t\t\t*******************************************************");
System.out.println("\t\t\t*\t CPAN BANCO CENTER *");
System.out.println("\t\t\t*******************************************************");
System.out.println("\t\t\t\t\n\t\t\t\t");
System.out.println("\t \t\t\t**************************************");
System.out.println("\t\t\t\t* EXCLUIR CONTA *");
System.out.println("\t \t\t\t**************************************");
System.out.println("\t\t\t\tDeseja realmente excluir uma conta bancaria?");
System.out.println("\t\t\tAo excluir, seus dados serão perdidos permanentemente");
System.out.println("\t \t\t\t**************************************");
System.out.println("\t\t\t\t* " + MenuExcluiConta.NAO.opcao + ".Nao *");
System.out.println("\t \t\t\t**************************************");
System.out.println("\t\t\t\t* " + MenuExcluiConta.SIM.opcao + ".Sim *");
System.out.println("\t \t\t\t**************************************");
System.out.println("\t\t\t\t\n\t\t\t\t");
opcao = TratamentodeEntradas.trataEntradaOpcao();
switch (MenuExcluirConta.menuConfirma(opcao)) {
case NAO:
sair = true;
break;
case SIM:
System.out.println();
System.out.printf("\t\t\t\tInforme o numero e a senha da conta que dejesa excluir: ");
System.out.println();
try {
conta = ContaDAO.read(TratamentodeEntradas.trataEntradaNumeroConta(),
EntradaDeDados.lerSenhaConta());
if (conta != null) {
if (conta.getPessoa().getCpf().equals(Controller.getSessao().getCpf())) {
System.out.println();
System.out.println("\t\t\t\t Confirme sua Senha de Login ");
System.out.println();
if (Controller.getSessao().getSenha().equals(EntradaDeDados.lerSenha())) {
System.out.println();
ContaDAO.delete(conta, Controller.getSessao());
if (conta == Controller.getSessao().getContaPadrao()) {
Controller.getSessao().setContaPadrao(null);
}
System.out.println();
System.out.println("[\t\t\t\t[Conta removida com sucesso]");
System.out.println();
ContaDAO.salvarContas();
PessoaDAO.salvarPessoas();
} else {
System.out.println();
System.out.println("\t\t\t\t[Senha Incorreta]");
System.out.println();
}
} else {
System.out.println();
System.out.println("\t\t\t\t[Conta nao encontrada]");
System.out.println();
}
}
} catch (Exception ex) {
System.out.println();
System.out.println("\t\t\t\t[Conta nao encontrada]");
System.out.println();
}
}
} catch (Exception e) {
System.out.println();
System.out.println("\t\t\t\tOpcao Invalida!");
System.out.println();
}
} while (!sair);
}
} | [
"nathalyamaral07@gmail.com"
] | nathalyamaral07@gmail.com |
92d270b3f9d1703e5fab62d4b986af1be6fcc6e1 | 2496767bfb6ed1f126e12ac00336a88dc5c85452 | /social_book/src/main/java/com/ronaldo/socialbook/domain/Author.java | a7bb293f7cc88b6d06990079b7af4c5f17e01c70 | [] | no_license | ronaldomartins06/socialbook | c404ac5c69b646960fe712185160f344be3f9380 | 97b07fddf2744af216e9e01a10e7bbe7f6214bfd | refs/heads/master | 2021-09-04T18:43:35.690937 | 2018-01-21T06:25:51 | 2018-01-21T06:25:51 | 98,397,841 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,714 | java | package com.ronaldo.socialbook.domain;
import java.util.Date;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.NotEmpty;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
@Entity
public class Author {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@NotEmpty(message="The field can't be empty")
private String name;
@JsonFormat(pattern="dd/MM/yyyy")
@NotNull(message="Filed is mandatory")
private Date birthday;
@JsonInclude(Include.NON_NULL)
@NotNull(message="Field is mandatory")
private String nationality;
@OneToMany(mappedBy="author")
@JsonIgnore
private List<Book> listBook;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getNationality() {
return nationality;
}
public void setNationality(String nationality) {
this.nationality = nationality;
}
public List<Book> getListBook() {
return listBook;
}
public void setListBook(List<Book> listBook) {
this.listBook = listBook;
}
}
| [
"Ronaldo Martins@192.168.0.227"
] | Ronaldo Martins@192.168.0.227 |
4687d94b6945e6dce980ea2557b8345190ac3736 | 031f47aef74e466085309c2bce44564aea650284 | /src/Demo/TrainglePascalReverse.java | 6c8802f166be297cf3c079b31b4d783e57eed5b0 | [] | no_license | basavan06/Java-Programs | 822b0862210baa38399335af3ff279bfb69683a0 | 2524364ea44bbc573b317476cd2d2341a2460b3e | refs/heads/master | 2016-08-11T22:11:24.767170 | 2016-03-13T03:59:07 | 2016-03-13T03:59:07 | 53,745,420 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 372 | java | package Demo;
public class TrainglePascalReverse {
public static void main(String[] args) {
for(int i=1;i<=7;i++)
{
for(int j=i;j>1;j--)
{
System.out.print(" ");
}
for(int k=1;k<=7-(i-1);k++)
{
System.out.print(i);
for(int k1=1;k1<k;k1+=k)
{
System.out.print(i);
}
}
System.out.println();
}
}
} | [
"Smiling Angel@Dell"
] | Smiling Angel@Dell |
e5db4182affec0f01edae2c2922d0a724b544fa6 | 01bac3bd6490d234435e3dd89c9bc732bb79ba79 | /src/main/java/io/harness/rest/matchers/Matcher.java | 5ac850adbb588aa5989fbf83fa3ac55981673a15 | [] | no_license | veereshradder90/Automation-Harn | 983fb08c76898cce438659bc51fc886557fd1710 | dec128978bb28330ed94eb6e0d70ec0a578b50be | refs/heads/main | 2023-02-10T15:11:18.184016 | 2021-01-11T08:13:31 | 2021-01-11T08:13:31 | 328,593,807 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 123 | java | package io.harness.rest.matchers;
public interface Matcher<T> { public boolean matches(Object actual, Object expected); }
| [
"Viresh.Radder@indecomm.com"
] | Viresh.Radder@indecomm.com |
e8861e5f2f2e2c318bb66a79689b54a6ab61c17f | 11827e24e158f2711cec1a69a1a79d0e6cd252ef | /Red-Libros-master/src/main/java/xmlModels/AlumnoXML.java | 48ec4b0b65d92207a7ac7acd06a99b1c20e5e6ce | [] | no_license | sharco-code/Red-Libros | b8116a68807a7827c19a6b7bed6a7aaf337001bf | b085426e564f8b7193ea0b801e18e7c4fdff7a8c | refs/heads/master | 2022-07-12T03:21:34.256073 | 2020-06-08T08:54:53 | 2020-06-08T08:54:53 | 246,033,920 | 0 | 0 | null | 2022-06-30T20:24:48 | 2020-03-09T12:48:11 | Java | UTF-8 | Java | false | false | 12,111 | java | package xmlModels;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "alumno")
@XmlAccessorType (XmlAccessType.FIELD)
public class AlumnoXML {
@XmlAttribute(name = "NIA")
private String nia;
@XmlAttribute
private String nombre;
@XmlAttribute
private String apellido1;
@XmlAttribute
private String apellido2;
@XmlAttribute(name = "fecha_nac")
private String fecha_nac;
@XmlAttribute(name = "municipio_nac")
private String municipio_nac;
@XmlAttribute(name = "municipio_nac_ext")
private String municipio_nac_ext;
@XmlAttribute(name = "provincia_nac")
private String provincia_nac;
@XmlAttribute(name = "pais_nac")
private String pais_nac;
@XmlAttribute
private String nacionalidad;
@XmlAttribute
private String sexo;
@XmlAttribute(name = "tipo_doc")
private String tipo_doc;
@XmlAttribute
private String documento;
@XmlAttribute
private String expediente;
@XmlAttribute(name = "libro_escolaridad")
private String libro_escoladirad;
@XmlAttribute(name = "cod_postal")
private String cod_postal;
@XmlAttribute(name = "tipo_via")
private String tipo_via;
@XmlAttribute
private String domicilio;
@XmlAttribute
private String numero;
@XmlAttribute
private String puerta;
@XmlAttribute
private String escalera;
@XmlAttribute
private String letra;
@XmlAttribute
private String piso;
@XmlAttribute
private String provincia;
@XmlAttribute
private String municipio;
@XmlAttribute
private String localidad;
@XmlAttribute
private String telefono1;
@XmlAttribute
private String telefono2;
@XmlAttribute
private String telefono3;
@XmlAttribute
private String email1;
@XmlAttribute
private String email2;
@XmlAttribute
private String sip;
@XmlAttribute
private String observaciones;
@XmlAttribute
private String ampa;
@XmlAttribute
private String seguro;
@XmlAttribute
private String dictamen;
@XmlAttribute(name = "fecha_resolucion")
private String fecha_resolucion;
@XmlAttribute(name = "informe_psicoped")
private String informe_psicoped;
@XmlAttribute(name = "informado_posib")
private String informado_posib;
@XmlAttribute(name = "fecha_matricula")
private String fecha_matricula;
@XmlAttribute(name = "fecha_ingreso_centro")
private String fecha_ingreso_centro;
@XmlAttribute(name = "estado matricula")
private String estado_matricula;
@XmlAttribute(name = "tipo_matricula")
private String tipo_matricula;
@XmlAttribute
private String repite;
@XmlAttribute(name = "num_repeticion")
private String num_repeticion;
@XmlAttribute
private String ensenanza;
@XmlAttribute
private String curso;
@XmlAttribute
private String grupo;
@XmlAttribute
private String turno;
@XmlAttribute
private String linea;
@XmlAttribute
private String trabaja;
@XmlAttribute(name = "fuera_comunidad")
private String fuera_comunidad;
@XmlAttribute(name = "matricula_parcial")
private String matricula_parcial;
@XmlAttribute(name = "matricula_condic")
private String matricula_condic;
@XmlAttribute(name = "informe_medico")
private String informe_medico;
@XmlAttribute
private String banco;
@XmlAttribute
private String sucursal;
@XmlAttribute(name = "digito_control")
private String digito_control;
@XmlAttribute
private String cuenta;
@XmlAttribute
private String modalidad;
@XmlAttribute
private String iban;
public AlumnoXML() {
super();
}
public String getNia() {
return nia;
}
public void setNia(String nia) {
this.nia = nia;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido1() {
return apellido1;
}
public void setApellido1(String apellido1) {
this.apellido1 = apellido1;
}
public String getApellido2() {
return apellido2;
}
public void setApellido2(String apellido2) {
this.apellido2 = apellido2;
}
public String getFecha_nac() {
return fecha_nac;
}
public void setFecha_nac(String fecha_nac) {
this.fecha_nac = fecha_nac;
}
public String getMunicipio_nac() {
return municipio_nac;
}
public void setMunicipio_nac(String municipio_nac) {
this.municipio_nac = municipio_nac;
}
public String getMunicipio_nac_ext() {
return municipio_nac_ext;
}
public void setMunicipio_nac_ext(String municipio_nac_ext) {
this.municipio_nac_ext = municipio_nac_ext;
}
public String getProvincia_nac() {
return provincia_nac;
}
public void setProvincia_nac(String provincia_nac) {
this.provincia_nac = provincia_nac;
}
public String getPais_nac() {
return pais_nac;
}
public void setPais_nac(String pais_nac) {
this.pais_nac = pais_nac;
}
public String getNacionalidad() {
return nacionalidad;
}
public void setNacionalidad(String nacionalidad) {
this.nacionalidad = nacionalidad;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
public String getTipo_doc() {
return tipo_doc;
}
public void setTipo_doc(String tipo_doc) {
this.tipo_doc = tipo_doc;
}
public String getDocumento() {
return documento;
}
public void setDocumento(String documento) {
this.documento = documento;
}
public String getExpediente() {
return expediente;
}
public void setExpediente(String expediente) {
this.expediente = expediente;
}
public String getLibro_escoladirad() {
return libro_escoladirad;
}
public void setLibro_escoladirad(String libro_escoladirad) {
this.libro_escoladirad = libro_escoladirad;
}
public String getCod_postal() {
return cod_postal;
}
public void setCod_postal(String cod_postal) {
this.cod_postal = cod_postal;
}
public String getTipo_via() {
return tipo_via;
}
public void setTipo_via(String tipo_via) {
this.tipo_via = tipo_via;
}
public String getDomicilio() {
return domicilio;
}
public void setDomicilio(String domicilio) {
this.domicilio = domicilio;
}
public String getNumero() {
return numero;
}
public void setNumero(String numero) {
this.numero = numero;
}
public String getPuerta() {
return puerta;
}
public void setPuerta(String puerta) {
this.puerta = puerta;
}
public String getEscalera() {
return escalera;
}
public void setEscalera(String escalera) {
this.escalera = escalera;
}
public String getLetra() {
return letra;
}
public void setLetra(String letra) {
this.letra = letra;
}
public String getPiso() {
return piso;
}
public void setPiso(String piso) {
this.piso = piso;
}
public String getProvincia() {
return provincia;
}
public void setProvincia(String provincia) {
this.provincia = provincia;
}
public String getMunicipio() {
return municipio;
}
public void setMunicipio(String municipio) {
this.municipio = municipio;
}
public String getLocalidad() {
return localidad;
}
public void setLocalidad(String localidad) {
this.localidad = localidad;
}
public String getTelefono1() {
return telefono1;
}
public void setTelefono1(String telefono1) {
this.telefono1 = telefono1;
}
public String getTelefono2() {
return telefono2;
}
public void setTelefono2(String telefono2) {
this.telefono2 = telefono2;
}
public String getTelefono3() {
return telefono3;
}
public void setTelefono3(String telefono3) {
this.telefono3 = telefono3;
}
public String getEmail1() {
return email1;
}
public void setEmail1(String email1) {
this.email1 = email1;
}
public String getEmail2() {
return email2;
}
public void setEmail2(String email2) {
this.email2 = email2;
}
public String getSip() {
return sip;
}
public void setSip(String sip) {
this.sip = sip;
}
public String getObservaciones() {
return observaciones;
}
public void setObservaciones(String observaciones) {
this.observaciones = observaciones;
}
public String getAmpa() {
return ampa;
}
public void setAmpa(String ampa) {
this.ampa = ampa;
}
public String getSeguro() {
return seguro;
}
public void setSeguro(String seguro) {
this.seguro = seguro;
}
public String getDictamen() {
return dictamen;
}
public void setDictamen(String dictamen) {
this.dictamen = dictamen;
}
public String getFecha_resolucion() {
return fecha_resolucion;
}
public void setFecha_resolucion(String fecha_resolucion) {
this.fecha_resolucion = fecha_resolucion;
}
public String getInforme_psicoped() {
return informe_psicoped;
}
public void setInforme_psicoped(String informe_psicoped) {
this.informe_psicoped = informe_psicoped;
}
public String getInformado_posib() {
return informado_posib;
}
public void setInformado_posib(String informado_posib) {
this.informado_posib = informado_posib;
}
public String getFecha_matricula() {
return fecha_matricula;
}
public void setFecha_matricula(String fecha_matricula) {
this.fecha_matricula = fecha_matricula;
}
public String getFecha_ingreso_centro() {
return fecha_ingreso_centro;
}
public void setFecha_ingreso_centro(String fecha_ingreso_centro) {
this.fecha_ingreso_centro = fecha_ingreso_centro;
}
public String getEstado_matricula() {
return estado_matricula;
}
public void setEstado_matricula(String estado_matricula) {
this.estado_matricula = estado_matricula;
}
public String getTipo_matricula() {
return tipo_matricula;
}
public void setTipo_matricula(String tipo_matricula) {
this.tipo_matricula = tipo_matricula;
}
public String getRepite() {
return repite;
}
public void setRepite(String repite) {
this.repite = repite;
}
public String getNum_repeticion() {
return num_repeticion;
}
public void setNum_repeticion(String num_repeticion) {
this.num_repeticion = num_repeticion;
}
public String getEnsenanza() {
return ensenanza;
}
public void setEnsenanza(String ensenanza) {
this.ensenanza = ensenanza;
}
public String getCurso() {
return curso;
}
public void setCurso(String curso) {
this.curso = curso;
}
public String getTurno() {
return turno;
}
public void setTurno(String turno) {
this.turno = turno;
}
public String getLinea() {
return linea;
}
public void setLinea(String linea) {
this.linea = linea;
}
public String getTrabaja() {
return trabaja;
}
public void setTrabaja(String trabaja) {
this.trabaja = trabaja;
}
public String getFuera_comunidad() {
return fuera_comunidad;
}
public void setFuera_comunidad(String fuera_comunidad) {
this.fuera_comunidad = fuera_comunidad;
}
public String getMatricula_parcial() {
return matricula_parcial;
}
public void setMatricula_parcial(String matricula_parcial) {
this.matricula_parcial = matricula_parcial;
}
public String getMatricula_condic() {
return matricula_condic;
}
public void setMatricula_condic(String matricula_condic) {
this.matricula_condic = matricula_condic;
}
public String getInforme_medico() {
return informe_medico;
}
public void setInforme_medico(String informe_medico) {
this.informe_medico = informe_medico;
}
public String getBanco() {
return banco;
}
public void setBanco(String banco) {
this.banco = banco;
}
public String getSucursal() {
return sucursal;
}
public void setSucursal(String sucursal) {
this.sucursal = sucursal;
}
public String getDigito_control() {
return digito_control;
}
public void setDigito_control(String digito_control) {
this.digito_control = digito_control;
}
public String getCuenta() {
return cuenta;
}
public void setCuenta(String cuenta) {
this.cuenta = cuenta;
}
public String getModalidad() {
return modalidad;
}
public void setModalidad(String modalidad) {
this.modalidad = modalidad;
}
public String getIban() {
return iban;
}
public void setIban(String iban) {
this.iban = iban;
}
public String getGrupo() {
return grupo;
}
public void setGrupo(String grupo) {
this.grupo = grupo;
}
}
| [
"48099382+RaulB0@users.noreply.github.com"
] | 48099382+RaulB0@users.noreply.github.com |
d6c8bd7d22f8af3c23170646fddd5ca1ae915766 | 5741045375dcbbafcf7288d65a11c44de2e56484 | /reddit-decompilada/kotlin/sequences/TransformingSequence.java | e3106362e33a13b8b42cf32107d1b975a73ff419 | [] | no_license | miarevalo10/ReporteReddit | 18dd19bcec46c42ff933bb330ba65280615c281c | a0db5538e85e9a081bf268cb1590f0eeb113ed77 | refs/heads/master | 2020-03-16T17:42:34.840154 | 2018-05-11T10:16:04 | 2018-05-11T10:16:04 | 132,843,706 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,048 | java | package kotlin.sequences;
import java.util.Iterator;
import kotlin.Metadata;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.Intrinsics;
@Metadata(bv = {1, 0, 2}, d1 = {"\u0000 \n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0002\b\u0004\n\u0002\u0010(\n\u0002\b\u0002\b\u0000\u0018\u0000*\u0004\b\u0000\u0010\u0001*\u0004\b\u0001\u0010\u00022\b\u0012\u0004\u0012\u0002H\u00020\u0003B'\u0012\f\u0010\u0004\u001a\b\u0012\u0004\u0012\u00028\u00000\u0003\u0012\u0012\u0010\u0005\u001a\u000e\u0012\u0004\u0012\u00028\u0000\u0012\u0004\u0012\u00028\u00010\u0006¢\u0006\u0002\u0010\u0007J3\u0010\b\u001a\b\u0012\u0004\u0012\u0002H\t0\u0003\"\u0004\b\u0002\u0010\t2\u0018\u0010\n\u001a\u0014\u0012\u0004\u0012\u00028\u0001\u0012\n\u0012\b\u0012\u0004\u0012\u0002H\t0\u000b0\u0006H\u0000¢\u0006\u0002\b\fJ\u000f\u0010\n\u001a\b\u0012\u0004\u0012\u00028\u00010\u000bH\u0002R\u0014\u0010\u0004\u001a\b\u0012\u0004\u0012\u00028\u00000\u0003X\u0004¢\u0006\u0002\n\u0000R\u001a\u0010\u0005\u001a\u000e\u0012\u0004\u0012\u00028\u0000\u0012\u0004\u0012\u00028\u00010\u0006X\u0004¢\u0006\u0002\n\u0000¨\u0006\r"}, d2 = {"Lkotlin/sequences/TransformingSequence;", "T", "R", "Lkotlin/sequences/Sequence;", "sequence", "transformer", "Lkotlin/Function1;", "(Lkotlin/sequences/Sequence;Lkotlin/jvm/functions/Function1;)V", "flatten", "E", "iterator", "", "flatten$kotlin_stdlib", "kotlin-stdlib"}, k = 1, mv = {1, 1, 9})
/* compiled from: Sequences.kt */
public final class TransformingSequence<T, R> implements Sequence<R> {
final Sequence<T> f33133a;
final Function1<T, R> f33134b;
public TransformingSequence(Sequence<? extends T> sequence, Function1<? super T, ? extends R> function1) {
Intrinsics.m26847b(sequence, "sequence");
Intrinsics.m26847b(function1, "transformer");
this.f33133a = sequence;
this.f33134b = function1;
}
public final Iterator<R> mo5679a() {
return new TransformingSequence$iterator$1(this);
}
}
| [
"mi.arevalo10@uniandes.edu.co"
] | mi.arevalo10@uniandes.edu.co |
fa6850c71c5b08c4aea7f1bf0f8695acdc522356 | 2f66b1db95bf75889f3f6f40194691454a75debb | /src/main/java/com/lfls/hotfix/ClientBootStrap.java | 8501cf58a4e88ed4247a97b89d3bd214af174592 | [] | no_license | zhenjunMa/JavaHotFix | 3ac2c706c74a35590a1cb5f7ba56786253e77a87 | a3156f0e145ddb3adaceb33f94f41839280371cf | refs/heads/master | 2023-06-22T12:53:17.457164 | 2022-02-15T03:53:37 | 2022-02-15T03:53:37 | 236,635,615 | 5 | 1 | null | 2022-02-15T03:53:38 | 2020-01-28T01:39:23 | Java | UTF-8 | Java | false | false | 478 | java | package com.lfls.hotfix;
import com.lfls.hotfix.client.Client;
import io.netty.util.ResourceLeakDetector;
/**
* @author lingfenglangshao
* @since 28/01/2020
*/
public class ClientBootStrap {
public static void main(String[] args) {
ResourceLeakDetector.setLevel(ResourceLeakDetector.Level.ADVANCED);
try {
new Client().start();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
}
| [
"lingfenglangshao@gmail.com"
] | lingfenglangshao@gmail.com |
3a5e207b1a1f1aabb77e40dfd6809669dac5ae93 | fc4d130c72eb501f2d63a81c7ccc40da4c134b5f | /weekendtask/demo/src/main/java/com/example/demo/model/Customer.java | 54550cb8abd93036ee515d90329f94998a76817a | [] | no_license | Sonampandey11/SpringBoot | cf4224d42b96799a0681416d45a172e66f79f4fd | 5802f57c262ac785168b85926eb57cdef36d998b | refs/heads/master | 2020-03-16T21:10:45.895084 | 2018-06-08T09:49:37 | 2018-06-08T09:49:37 | 132,987,727 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,707 | java | package com.example.demo.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import org.hibernate.annotations.GeneratorType;
import com.example.demo.customannotation.Sonam;
@Entity
public class Customer {
@Id
@Column(name="customerId")
private Integer customerId;
@Column(name="customerName")
private String customerName;
@Column(name="customerAddress")
private String customerAddress;
@Column(name="payementMode")
private String paymentMode;
@Column(name="retailerId")
private Integer retailerId;
/**
* @return the retailerId
*/
public Integer getRetailerId() {
return retailerId;
}
/**
* @param retailerId the retailerId to set
*/
public void setRetailerId(Integer retailerId) {
this.retailerId = retailerId;
}
/**
* @return the customerId
*/
public Integer getCustomerId() {
return customerId;
}
/**
* @param customerId the customerId to set
*/
public void setCustomerId(final Integer customerId) {
this.customerId = customerId;
}
/**
* @return the customerName
*/
public String getCustomerName() {
return customerName;
}
/**
* @param customerName the customerName to set
*/
public void setCustomerName(final String customerName) {
this.customerName = customerName;
}
/**
* @return the customerAddress
*/
public String getCustomerAddress() {
return customerAddress;
}
/**
* @param customerAddress the customerAddress to set
*/
public void setCustomerAddress(final String customerAddress) {
this.customerAddress = customerAddress;
}
/**
* @return the paymentMode
*/
public String getPaymentMode() {
return paymentMode;
}
/**
* @param paymentMode the paymentMode to set
*/
public void setPaymentMode(final String paymentMode) {
this.paymentMode = paymentMode;
}
/**
* @param customerId
* @param customerName
* @param customerAddress
* @param paymentMode
* @param retailerId
*/
public Customer(Integer customerId, String customerName, String customerAddress, String paymentMode, int retailerId) {
this.customerId = customerId;
this.customerName = customerName;
this.customerAddress = customerAddress;
this.paymentMode = paymentMode;
this.retailerId = retailerId;
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
/**
*
*/
public Customer() {
super();
// TODO Auto-generated constructor stub
}
/* (non-Javadoc)
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Customer [customerId=" + customerId + ", customerName=" + customerName + ", customerAddress="
+ customerAddress + ", paymentMode=" + paymentMode + ", retailerId=" + retailerId + "]";
}
}
| [
"sonam.pandey@capgemini.com"
] | sonam.pandey@capgemini.com |
e748f74d9b7ec136d3575ce6664af7f61ce94476 | 22f29384948cd9458a3372b81171b255de16389d | /Desktop/BusTransportingSystemBackend/src/main/java/BusTransportingSystem/services/IBusService.java | 75e6b5682b5412036672523ab2e03ae22da0ae79 | [] | no_license | smgijima/BusTransportingSystemBackend | 2d97c737863d2b8fbe6d644b3017774a80477886 | 02a41ab0f0fab1e7f9cae4423c1907e7b109c201 | refs/heads/master | 2020-12-03T13:37:29.073846 | 2016-09-02T21:45:05 | 2016-09-02T21:45:08 | 67,258,092 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 204 | java | package BusTransportingSystem.services;
import BusTransportingSystem.domain.BusDetails;
/**
* Created by Cornelious on 7/31/2016.
*/
public interface IBusService extends Services<BusDetails,Long> {
}
| [
"210120932@mycput.ac.za"
] | 210120932@mycput.ac.za |
68d2d83767f92cd4d2faa1e5bc78058f17843bb8 | 1dd2c51fd68b819af41e06ab1aa8a4418cb531d8 | /jaxrs/src/main/java/com/proofpoint/jaxrs/testing/GuavaMultivaluedMap.java | 1746f84aab0b66e3006549da85fdd8d06ea188d4 | [
"Apache-2.0"
] | permissive | proofpoint/platform | 768ba49f00c019f5745892bcd714f73b04db3ce2 | c6e9f0444d0fea936453ece83670d970caf43ee3 | refs/heads/master | 2023-08-25T15:01:42.955632 | 2023-08-24T17:10:20 | 2023-08-24T18:50:02 | 1,384,929 | 59 | 78 | Apache-2.0 | 2023-09-14T20:52:50 | 2011-02-19T01:26:11 | Java | UTF-8 | Java | false | false | 1,779 | java | package com.proofpoint.jaxrs.testing;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ForwardingMap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multimaps;
import jakarta.ws.rs.core.MultivaluedMap;
import java.util.List;
import java.util.Map;
public class GuavaMultivaluedMap<K, V>
extends ForwardingMap<K, List<V>>
implements MultivaluedMap<K, V>
{
private final ListMultimap<K, V> multimap = ArrayListMultimap.create();
public GuavaMultivaluedMap()
{
}
public GuavaMultivaluedMap(Multimap<K, V> multimap)
{
this.multimap.putAll(multimap);
}
@Override
public void putSingle(K key, V value)
{
multimap.removeAll(key);
multimap.put(key, value);
}
@Override
protected Map<K, List<V>> delegate()
{
return Multimaps.asMap(multimap);
}
@Override
public void add(K key, V value)
{
multimap.put(key, value);
}
@SafeVarargs
@Override
public final void addAll(K key, V... newValues)
{
multimap.putAll(key, ImmutableList.copyOf(newValues));
}
@Override
public void addAll(K key, List<V> valueList)
{
multimap.putAll(key, valueList);
}
@Override
public V getFirst(K key)
{
return multimap.get(key).stream().findFirst().orElse(null);
}
@Override
public void addFirst(K key, V value)
{
throw new UnsupportedOperationException();
}
@Override
public boolean equalsIgnoreValueOrder(MultivaluedMap<K, V> otherMap)
{
throw new UnsupportedOperationException();
}
}
| [
"jgmyers@proofpoint.com"
] | jgmyers@proofpoint.com |
6ead5a2b9f0e88d0b174ab2fb872c7f0ffa47be5 | a033e1aa29e5930bec36df2bf1d0a7cb871d445f | /Counting Tilings/src/Main.java | 2bd7cebe436dbe77e7209fa0600cf160e9f50c5c | [] | no_license | Sahil-Gupta582/CSES | db44d2564c94c31bb21551809c9fd73faa88a78d | d8b89cb202f017100cbef55b4c799f3cb427a190 | refs/heads/main | 2023-07-09T03:02:54.663297 | 2021-08-06T18:49:38 | 2021-08-06T18:49:38 | 387,137,766 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 4,626 | java | import java.io.*;
import java.util.*;
import java.text.DecimalFormat;
public class Main {
static long mod=(long)1e9+7;
static long mod1=998244353;
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
int t= 1;
while(t-->0) {
int n = in.nextInt();
int m =in.nextInt();
boolean[][] visit = new boolean[n][m];
out.println(getAms(visit,0,n*m,n,m));
}
out.close();
}
static long getAms(boolean[][] visit,int r, int area,int n, int m){
if(area == 0)
return 1;
if(r==n)
return -1;
int ans = 0;
for(int i = 0;i<m;i++){
if(!visit[r][i]){
boolean flag = false;
if(i+1<m && !visit[r][i+1]){
flag = true;
visit[r][i] = visit[r][i+1] = true;
ans+=getAms(visit,(i+1==n-1)?r+1:r,area-2,n,m);
visit[r][i] = visit[r][i+1] = false;
}
if(r+1<n && !visit[r+1][i]){
flag = true;
visit[r+1][i]=visit[r][i]=true;
ans+=getAms(visit,(i==n-1)?r+1:r,area-2,n,m);
visit[r+1][i]=visit[r][i]=false;
}
if(!flag) {
System.out.println("Hello");
return -1;
}
}
}
return ans;
}
static final Random random=new Random();
static void ruffleSort(int[] a) {
int n=a.length;//shuffle, then sort
for (int i=0; i<n; i++) {
int oi=random.nextInt(n), temp=a[oi];
a[oi]=a[i]; a[i]=temp;
}
Arrays.sort(a);
}
static long gcd(long x, long y){
if(x==0)
return y;
if(y==0)
return x;
long r=0, a, b;
a = Math.max(x, y);
b = Math.min(x, y);
r = b;
while(a % b != 0){
r = a % b;
a = b;
b = r;
}
return r;
}
static long modulo(long a,long b,long c){
long x=1,y=a%c;
while(b > 0){
if(b%2 == 1)
x=(x*y)%c;
y = (y*y)%c;
b = b>>1;
}
return x%c;
}
public static void debug(Object... o){
System.err.println(Arrays.deepToString(o));
}
static int upper_bound(int[] arr,int n,int x){
int mid;
int low=0;
int high=n;
while(low<high){
mid=low+(high-low)/2;
if(x>=arr[mid])
low=mid+1;
else
high=mid;
}
return low;
}
static int lower_bound(int[] arr,int n,int x){
int mid;
int low=0;
int high=n;
while(low<high){
mid=low+(high-low)/2;
if(x<=arr[mid])
high=mid;
else
low=mid+1;
}
return low;
}
static String printPrecision(double d){
DecimalFormat ft = new DecimalFormat("0.00000000000");
return String.valueOf(ft.format(d));
}
static int countBit(long mask){
int ans=0;
while(mask!=0){
mask&=(mask-1);
ans++;
}
return ans;
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] readArray(int n)
{
int[] arr=new int[n];
for(int i=0;i<n;i++) arr[i]=nextInt();
return arr;
}
}
} | [
"sahilgupta.btech.cs19@iiitranchi.ac.in"
] | sahilgupta.btech.cs19@iiitranchi.ac.in |
0c4ba1874a0bef9876595238c5dd1b8d8aa9efe6 | b40591ea380eced5360cc9f30e55a766f3a66585 | /qunaer/App/src/main/java/com/iflytek/aiui/AIUIEvent.java | 80bbdc1234003787f2b2c2d75e493597eef18d3d | [] | no_license | PoseidonMRT/UserfulCodeResource | 08935f4155ac7567fc279300a03f80337f9a5516 | 040dacc22c236fde06f650c46c5cfeb8d52171c0 | refs/heads/master | 2022-10-09T13:00:48.616694 | 2019-04-19T02:42:45 | 2019-04-19T02:42:45 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 651 | java | package com.iflytek.aiui;
import android.os.Bundle;
public final class AIUIEvent implements Cloneable {
public int arg1;
public int arg2;
public Bundle data;
public int eventType;
public String info;
public AIUIEvent(int i, int i2, int i3, String str, Bundle bundle) {
this.eventType = i;
this.arg1 = i2;
this.arg2 = i3;
this.info = str;
this.data = bundle;
}
public Object clone() {
AIUIEvent aIUIEvent = (AIUIEvent) super.clone();
if (this.data != null) {
aIUIEvent.data = (Bundle) this.data.clone();
}
return aIUIEvent;
}
}
| [
"1044176601@qq.com"
] | 1044176601@qq.com |
b79c093b1d97d400580ca435bc77f869ba995583 | 6ee5e64d569ef0079be6328a4d6a96fad68a3723 | /myprj2/src/user/view/content/UserMyOrderDetailView.java | 6930c36f5aaa8c9346f7ab855fc08073e198f3e9 | [] | no_license | hbin99/myprj2_clothesShoppingMall | 4aac7ecc19353ce206d51b8e9bc5223e4cb0d2c4 | 3b48235e2567df6b123f55774a53cd28d68e0a99 | refs/heads/master | 2020-12-20T03:46:34.456642 | 2020-01-25T05:54:09 | 2020-01-25T05:54:09 | 235,950,723 | 0 | 0 | null | null | null | null | UHC | Java | false | false | 8,828 | java | package user.view.content;
import java.awt.Color;
import java.awt.Font;
import java.awt.Image;
import javax.swing.DefaultComboBoxModel;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.EtchedBorder;
import javax.swing.border.LineBorder;
import admin.run.StaticCla;
import user.controller.content.UserMyOrderDetailEvt;
import user.vo.content.SelectMyOrderDetailDTO;
@SuppressWarnings("serial")
public class UserMyOrderDetailView extends JDialog {
private JLabel jtfGoodsName, jtfbuyNum, jtfbuyMethod, jtfTotalPrice, jtfOrderDate, jtfDeliveryFlag, jtfDeliverMsg,
jtfOrderCode, jtfGoodsCode, jlScore;
private DefaultComboBoxModel<Integer> dcbmScore;
private JComboBox<Integer> jcbScore;
private JButton jbtnClose, jbtnScore;
private JLabel jlImg;
private SelectMyOrderDetailDTO moDTO;
public UserMyOrderDetailView(SelectMyOrderDetailDTO moDTO) {
super(StaticCla.mv, "상품관리-상세보기", true);
this.moDTO = moDTO;
// 이미지
ImageIcon iiImage = new ImageIcon(StaticCla.FILE_PATH + "/gd_" + moDTO.getG_img());
Image img = iiImage.getImage();
Image chgimg = img.getScaledInstance(250, 350, Image.SCALE_SMOOTH);// 이미지 사이즈변경
ImageIcon newImg = new ImageIcon(chgimg);
jlImg = new JLabel(newImg);
jlImg.setBorder(new EtchedBorder(EtchedBorder.RAISED)); // border돌출
Font font = new Font("맑은 고딕", Font.BOLD, 20);
Font fontCon = new Font("맑은 고딕", Font.BOLD, 15);
// 라벨
JTextField jlTitle = new JTextField(" 주문정보 ");
Font titleFont = new Font("맑은 고딕", Font.BOLD, 20);
jlTitle.setFont(titleFont);
jlTitle.setBackground(new Color(0x352A26));
jlTitle.setForeground(Color.white);
jlTitle.setHorizontalAlignment(JTextField.CENTER);
// 평점
Integer[] score = { 5, 4, 3, 2, 1 };
dcbmScore = new DefaultComboBoxModel<Integer>(score);
jcbScore = new JComboBox<Integer>(dcbmScore);
JLabel jlPayTitle = new JLabel("※상품 및 결제정보 ※ ");
jlPayTitle.setForeground(Color.white);
JLabel jlDeliTitle = new JLabel("※배송정보 ※ ");
jlDeliTitle.setForeground(Color.white);
jlTitle.setFont(font);
JLabel jlGoodsName = new JLabel("상품명 :");//
jlGoodsName.setFont(fontCon);
JLabel jlbuyNum = new JLabel("구매수량 :");//
jlbuyNum.setFont(fontCon);
JLabel jlscore = new JLabel("상품평점 :");//
jlscore.setFont(fontCon);
JLabel jlbuyMethod = new JLabel("결제방식 :");//
jlbuyMethod.setFont(fontCon);
JLabel jlTotalPrice = new JLabel("총 결제금액 :");//
jlTotalPrice.setFont(fontCon);
JLabel jlOrderDate = new JLabel("주문날짜 :");//
jlOrderDate.setFont(fontCon);
JLabel jlDeliveryFlag = new JLabel("배송여부 :");//
jlDeliveryFlag.setFont(fontCon);
JLabel jlDeliverMsg = new JLabel("배송요청사항 :");//
jlDeliverMsg.setFont(fontCon);
jtfGoodsName = new JLabel();
jtfbuyNum = new JLabel();
jtfbuyMethod = new JLabel();
jtfTotalPrice = new JLabel();
jtfOrderDate = new JLabel();
jtfDeliveryFlag = new JLabel();
jtfDeliverMsg = new JLabel();
jtfOrderCode = new JLabel();
jtfGoodsCode = new JLabel();
jbtnScore = new JButton("평점주기");
jbtnClose = new JButton("확인");
// setText
jtfGoodsCode.setText(moDTO.getG_code());
jtfOrderCode.setText(moDTO.getO_code());
jtfGoodsName.setText(moDTO.getG_name());
jtfbuyNum.setText(String.valueOf(moDTO.getO_quantity()) + " 개");
jtfbuyMethod.setText(moDTO.getP_method() + "카드");
jtfTotalPrice.setText(String.valueOf(moDTO.getO_buypay()) + " 원");
jtfOrderDate.setText(moDTO.getO_date());
jtfDeliveryFlag.setText(moDTO.getO_delivery());
jtfDeliverMsg.setText(moDTO.getO_delmsg());
if (moDTO.getO_delmsg() == null || "".equals(moDTO.getO_delmsg())) {
jtfDeliverMsg.setText("배송 요청사항이 없습니다.");
} // end if
JPanel jpGoods = new JPanel();
jpGoods.setLayout(null);
jlGoodsName.setBounds(15, 10, 60, 30);
jpGoods.add(jlGoodsName);
jlbuyNum.setBounds(15, 60, 100, 30);//
jpGoods.add(jlbuyNum);//
jlbuyMethod.setBounds(15, 110, 100, 30);
jpGoods.add(jlbuyMethod);
jlTotalPrice.setBounds(15, 160, 110, 30);
jpGoods.add(jlTotalPrice);
jlOrderDate.setBounds(15, 210, 80, 30);
jpGoods.add(jlOrderDate);
jtfGoodsName.setBounds(90, 10, 230, 30);
jpGoods.add(jtfGoodsName);
jtfbuyNum.setBounds(100, 60, 80, 30);//
jpGoods.add(jtfbuyNum);//
jtfbuyMethod.setBounds(100, 110, 230, 30);
jpGoods.add(jtfbuyMethod);
jtfTotalPrice.setBounds(120, 160, 230, 30);
jpGoods.add(jtfTotalPrice);
jtfOrderDate.setBounds(90, 210, 230, 30);
jpGoods.add(jtfOrderDate);
// 평점
jlscore.setBounds(15, 260, 70, 30);
jpGoods.add(jlscore);
// jlScore.setText(String.valueOf(moDTO.getO_score()));
if (moDTO.getO_score() == 0) {
jcbScore.setBounds(90, 260, 50, 30);
jbtnScore.setBounds(160, 260, 100, 30);
jpGoods.add(jcbScore);
jpGoods.add(jbtnScore);
} else {
switch (moDTO.getO_score()) {
case 5:
jlScore = new JLabel("★★★★★");
jlScore.setBounds(90, 260, 200, 30);
jpGoods.add(jlScore);
break;
case 4:
jlScore = new JLabel("★★★★☆");
jlScore.setBounds(90, 260, 200, 30);
jpGoods.add(jlScore);
break;
case 3:
jlScore = new JLabel("★★★☆☆");
jlScore.setBounds(90, 260, 200, 30);
jpGoods.add(jlScore);
break;
case 2:
jlScore = new JLabel("★★☆☆☆");
jlScore.setBounds(90, 260, 200, 30);
jpGoods.add(jlScore);
break;
case 1:
jlScore = new JLabel("★☆☆☆☆");
jlScore.setBounds(90, 260, 200, 30);
jpGoods.add(jlScore);
break;
default:
jlScore = new JLabel("");
break;
}// switch
jlScore.setForeground(Color.red);
} // end else
JPanel jpDelivery = new JPanel();
jpDelivery.setLayout(null);
jlDeliveryFlag.setBounds(10, 10, 150, 30);
jpDelivery.add(jlDeliveryFlag);
jlDeliverMsg.setBounds(10, 50, 150, 30);
jpDelivery.add(jlDeliverMsg);
jtfDeliveryFlag.setBounds(120, 10, 180, 30);
jpDelivery.add(jtfDeliveryFlag);
jtfDeliverMsg.setBounds(120, 50, 450, 30);
jpDelivery.add(jtfDeliverMsg);
// 수정못하게 막음
// jlTitle.setBorder(new LineBorder(new Color(0x352A26)));
jlTitle.setEditable(false);
setLayout(null); // 수동
jlTitle.setBounds(50, 10, 200, 30);
jlImg.setBounds(10, 60, 270, 340);
Font fontLabel = new Font("맑은 고딕", Font.BOLD, 17);
jlPayTitle.setFont(fontLabel);
jlDeliTitle.setFont(fontLabel);
jlPayTitle.setBounds(300, 30, 200, 40);
jlDeliTitle.setBounds(40, 410, 200, 40);
jpGoods.setBounds(290, 70, 360, 320);
jpGoods.setBorder(new LineBorder(Color.lightGray));
jpDelivery.setBounds(15, 450, 630, 100);
jpDelivery.setBorder(new LineBorder(Color.lightGray));
jbtnClose.setBounds(280, 570, 120, 30);
jbtnScore.setForeground(Color.white);
jbtnScore.setBackground(new Color(0x043424));
jbtnClose.setForeground(Color.black);
jbtnClose.setBackground(Color.white);
add(jlTitle);
add(jlImg);
add(jpGoods);
add(jpDelivery);
add(jbtnClose);
add(jlPayTitle);
add(jlDeliTitle);
this.getContentPane().setBackground(new Color(0x352A26)); // JDialog 배경색 변경
setBounds(100, 100, 700, 680);
UserMyOrderDetailEvt ume = new UserMyOrderDetailEvt(this);
jbtnClose.addActionListener(ume);
jbtnScore.addActionListener(ume);
setVisible(true);
setResizable(false);
}// AdOrderDetailView
public JLabel getJtfGoodsName() {
return jtfGoodsName;
}
public JLabel getJtfbuyNum() {
return jtfbuyNum;
}
public JLabel getJtfbuyMethod() {
return jtfbuyMethod;
}
public JLabel getJtfTotalPrice() {
return jtfTotalPrice;
}
public JLabel getJtfOrderDate() {
return jtfOrderDate;
}
public JLabel getJtfDeliveryFlag() {
return jtfDeliveryFlag;
}
public JLabel getJtfDeliverMsg() {
return jtfDeliverMsg;
}
public JLabel getJtfOrderCode() {
return jtfOrderCode;
}
public DefaultComboBoxModel<Integer> getDcbmScore() {
return dcbmScore;
}
public JComboBox<Integer> getJcbScore() {
return jcbScore;
}
public JButton getJbtnClose() {
return jbtnClose;
}
public JButton getJbtnScore() {
return jbtnScore;
}
public JLabel getJlImg() {
return jlImg;
}
public SelectMyOrderDetailDTO getMoDTO() {
return moDTO;
}
public JLabel getJtfGoodsCode() {
return jtfGoodsCode;
}
}// class
| [
"hyebin@DESKTOP-KE3UFEG"
] | hyebin@DESKTOP-KE3UFEG |
72091e0f0c773093f2d025e9f6294a7af0dcaa11 | 5ca2f3d90cc83e3e3cf55fba3769e953a8567547 | /src/main/java/edu/javavt18/service/CarModelService.java | 92404a91dcf2d59d73ae2cf767b6244898a81194 | [] | no_license | Malev-dev/Course_work_java_mlv | 6f61d07e1233e4fe6c3c97e5bf94d0c3b6d8f0e5 | a7139014256b4ba1cabd5f3aafa03b81a74aa285 | refs/heads/master | 2023-01-31T05:07:16.468136 | 2020-12-14T19:33:02 | 2020-12-14T19:33:02 | 320,055,370 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 253 | java | package edu.javavt18.service;
import edu.javavt18.model.CarModel;
import java.util.List;
public interface CarModelService {
void saveOrUpdate(CarModel item);
void delete(int itemId);
CarModel get(int itemId);
List<CarModel> list();
} | [
"malevanydrg1@ukr.net"
] | malevanydrg1@ukr.net |
a4b5889d2a70502da13dff975d41b237e59daaf2 | 7537b062c5d46ad20d9205e008f69740b9e49291 | /src/main/java/com/aop/exercise/service/OutputService.java | bd94795546c6895dcb111e041b3d0b742753cfa8 | [] | no_license | shehanab/spring-aop | a9aba782872d25870f8e31b5f12fe53074a131fb | 46f8be1db926a32765ed4e8eb64e63772e93d345 | refs/heads/master | 2022-12-01T01:19:19.639930 | 2020-08-22T02:59:21 | 2020-08-22T02:59:21 | 289,134,707 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 817 | java | package com.aop.exercise.service;
import com.aop.exercise.aspect.Countable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
@Service
public class OutputService {
@Value("${app.name}")
private String name;
private final GreetingService greetingService;
private final TimeService timeService;
@Autowired
public OutputService(GreetingService greetingService, TimeService timeService){
this.greetingService = greetingService;
this.timeService = timeService;
}
@Countable
public void generateOutput(){
String output = timeService.getCurrentTime() + " " + greetingService.getGreeting(name);
System.out.println(output);
}
}
| [
"shehan.a@ncs.com.sg"
] | shehan.a@ncs.com.sg |
7f17d07c484d1f465b629984f8b938cb2e7ca69b | 455e19b93fe38ee5a780cccce6891512f938420e | /src/java/com/uas/googleDriveBackups/googleDriveBackupInterface.java | 43663cd42e6e9d26b2bd28d38715458806e468bd | [] | no_license | jgil1967/wsjava | 80d18cfe767c6ad4a79d8fd07daf26c9389bdb6c | 91f457fbae48a9a2509fa690071817bd81775565 | refs/heads/master | 2021-01-18T03:57:45.924716 | 2017-03-27T04:39:34 | 2017-03-27T04:39:34 | 85,773,137 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 505 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.uas.googleDriveBackups;
import com.uas.document.DocumentDTO;
import java.util.ArrayList;
/**
*
* @author jonathangil
*/
public interface googleDriveBackupInterface {
googleDriveBackupDTO creategoogleDriveBackup (googleDriveBackupDTO dto);
ArrayList <googleDriveBackupDTO> getBackups ();
}
| [
"jgil1967@hotmail.com"
] | jgil1967@hotmail.com |
842803afde6ce6d1d6a07acde8ceff723ea7090c | edabb15cb09ce6cb3a0f2d4d1dfe17850b5d8554 | /src/main/java/org/bitbucket/ytimes/client/kkm/record/PrinterType.java | eefb3f53cfa2fc3cdf94b3b67966ebb1be4dad00 | [
"MIT"
] | permissive | ytimesru/kkm-pc-client | 74f7eecd30fb1ef1f29c43a85ecbf18a78935646 | 899a6f00b2067a5d0823fd3d468be693af1dbdba | refs/heads/master | 2021-01-25T09:10:42.038884 | 2018-08-11T20:07:11 | 2018-08-11T20:07:11 | 93,795,952 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 109 | java | package org.bitbucket.ytimes.client.kkm.record;
public enum PrinterType {
NONE,
TEST,
ATOL;
}
| [
"andrey.trakhirov@magenta-technology.com"
] | andrey.trakhirov@magenta-technology.com |
18950d9bab244f0f52d3dbaa696f6d3d1803208c | 6eb19556bb28b431c40c67a8af87ebc1af84479e | /src/main/java/aiss/model/photos/filter/ContentFilter.java | 28edb54112b3168b6fedac6353d9efb333cbec36 | [
"MIT"
] | permissive | nicolasdeory/moovid | 6e76e0ee44e9e8be759758fd741c05b36660090c | 895b45b353e3f2fe5d982c9c4c9c9efd83396f49 | refs/heads/master | 2022-06-25T07:29:07.770324 | 2021-05-08T13:53:08 | 2021-05-08T13:53:08 | 245,620,950 | 0 | 1 | MIT | 2022-06-17T01:56:18 | 2020-03-07T11:33:12 | JavaScript | UTF-8 | Java | false | false | 1,989 | java |
package aiss.model.photos.filter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({
"includedContentCategories",
"excludedContentCategories"
})
public class ContentFilter {
@Override
public String toString() {
return "ContentFilter [includedContentCategories=" + includedContentCategories + ", excludedContentCategories="
+ excludedContentCategories + "]";
}
@JsonProperty("includedContentCategories")
private List<String> includedContentCategories = null;
@JsonProperty("excludedContentCategories")
private List<String> excludedContentCategories = null;
public ContentFilter(List<String> includedContentCategories,
List<String> excludedContentCategories) {
super();
this.includedContentCategories = includedContentCategories;
this.excludedContentCategories = excludedContentCategories;
}
@JsonProperty("includedContentCategories")
public List<String> getIncludedContentCategories() {
return includedContentCategories;
}
@JsonProperty("includedContentCategories")
public void setIncludedContentCategories(List<String> includedContentCategories) {
this.includedContentCategories = includedContentCategories;
}
@JsonProperty("excludedContentCategories")
public List<String> getExcludedContentCategories() {
return excludedContentCategories;
}
@JsonProperty("excludedContentCategories")
public void setExcludedContentCategories(List<String> excludedContentCategories) {
this.excludedContentCategories = excludedContentCategories;
}
}
| [
"danielcaroolmedo2@gmail.com"
] | danielcaroolmedo2@gmail.com |
a8ececfc10fe36b8d66113d95615c6480b1650ff | 12b14b30fcaf3da3f6e9dc3cb3e717346a35870a | /examples/commons-math3/mutations/mutants-HypergeometricDistribution/137/org/apache/commons/math3/distribution/HypergeometricDistribution.java | 0cba554838677c7ef9561849a370a2440ae5c113 | [
"BSD-3-Clause",
"Minpack",
"Apache-2.0"
] | permissive | SmartTests/smartTest | b1de326998857e715dcd5075ee322482e4b34fb6 | b30e8ec7d571e83e9f38cd003476a6842c06ef39 | refs/heads/main | 2023-01-03T01:27:05.262904 | 2020-10-27T20:24:48 | 2020-10-27T20:24:48 | 305,502,060 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 11,831 | java | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math3.distribution;
import org.apache.commons.math3.exception.NotPositiveException;
import org.apache.commons.math3.exception.NotStrictlyPositiveException;
import org.apache.commons.math3.exception.NumberIsTooLargeException;
import org.apache.commons.math3.exception.util.LocalizedFormats;
import org.apache.commons.math3.util.FastMath;
import org.apache.commons.math3.random.RandomGenerator;
import org.apache.commons.math3.random.Well19937c;
/**
* Implementation of the hypergeometric distribution.
*
* @see <a href="http://en.wikipedia.org/wiki/Hypergeometric_distribution">Hypergeometric distribution (Wikipedia)</a>
* @see <a href="http://mathworld.wolfram.com/HypergeometricDistribution.html">Hypergeometric distribution (MathWorld)</a>
* @version $Id$
*/
public class HypergeometricDistribution extends AbstractIntegerDistribution {
/** Serializable version identifier. */
private static final long serialVersionUID = -436928820673516179L;
/** The number of successes in the population. */
private final int numberOfSuccesses;
/** The population size. */
private final int populationSize;
/** The sample size. */
private final int sampleSize;
/** Cached numerical variance */
private double numericalVariance = Double.NaN;
/** Whether or not the numerical variance has been calculated */
private boolean numericalVarianceIsCalculated = false;
/**
* Construct a new hypergeometric distribution with the specified population
* size, number of successes in the population, and sample size.
*
* @param populationSize Population size.
* @param numberOfSuccesses Number of successes in the population.
* @param sampleSize Sample size.
* @throws NotPositiveException if {@code numberOfSuccesses < 0}.
* @throws NotStrictlyPositiveException if {@code populationSize <= 0}.
* @throws NumberIsTooLargeException if {@code numberOfSuccesses > populationSize},
* or {@code sampleSize > populationSize}.
*/
public HypergeometricDistribution(int populationSize, int numberOfSuccesses, int sampleSize)
throws NotPositiveException, NotStrictlyPositiveException, NumberIsTooLargeException {
this(new Well19937c(), populationSize, numberOfSuccesses, sampleSize);
}
/**
* Creates a new hypergeometric distribution.
*
* @param rng Random number generator.
* @param populationSize Population size.
* @param numberOfSuccesses Number of successes in the population.
* @param sampleSize Sample size.
* @throws NotPositiveException if {@code numberOfSuccesses < 0}.
* @throws NotStrictlyPositiveException if {@code populationSize <= 0}.
* @throws NumberIsTooLargeException if {@code numberOfSuccesses > populationSize},
* or {@code sampleSize > populationSize}.
* @since 3.1
*/
public HypergeometricDistribution(RandomGenerator rng,
int populationSize,
int numberOfSuccesses,
int sampleSize)
throws NotPositiveException, NotStrictlyPositiveException, NumberIsTooLargeException {
super(rng);
if (populationSize <= 0) {
throw new NotStrictlyPositiveException(LocalizedFormats.POPULATION_SIZE,
populationSize);
}
if (numberOfSuccesses < 0) {
throw new NotPositiveException(LocalizedFormats.NUMBER_OF_SUCCESSES,
numberOfSuccesses);
}
if (sampleSize < 0) {
throw new NotPositiveException(LocalizedFormats.NUMBER_OF_SAMPLES,
sampleSize);
}
if (numberOfSuccesses > populationSize) {
throw new NumberIsTooLargeException(LocalizedFormats.NUMBER_OF_SUCCESS_LARGER_THAN_POPULATION_SIZE,
numberOfSuccesses, populationSize, true);
}
if (sampleSize > populationSize) {
throw new NumberIsTooLargeException(LocalizedFormats.SAMPLE_SIZE_LARGER_THAN_POPULATION_SIZE,
sampleSize, populationSize, true);
}
this.numberOfSuccesses = numberOfSuccesses;
this.populationSize = populationSize;
this.sampleSize = sampleSize;
}
/** {@inheritDoc} */
public double cumulativeProbability(int x) {
double ret;
int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
if (x < domain[0]) {
ret = 0.0;
} else if (x >= domain[1]) {
ret = 1.0;
} else {
ret = innerCumulativeProbability(domain[0], x, 1);
}
return ret;
}
/**
* Return the domain for the given hypergeometric distribution parameters.
*
* @param n Population size.
* @param m Number of successes in the population.
* @param k Sample size.
* @return a two element array containing the lower and upper bounds of the
* hypergeometric distribution.
*/
private int[] getDomain(int n, int m, int k) {
return new int[] { getLowerDomain(n, m, k), getUpperDomain(m, k) };
}
/**
* Return the lowest domain value for the given hypergeometric distribution
* parameters.
*
* @param n Population size.
* @param m Number of successes in the population.
* @param k Sample size.
* @return the lowest domain value of the hypergeometric distribution.
*/
private int getLowerDomain(int n, int m, int k) {
return FastMath.max(0, m - (n - k));
}
/**
* Access the number of successes.
*
* @return the number of successes.
*/
public int getNumberOfSuccesses() {
return numberOfSuccesses;
}
/**
* Access the population size.
*
* @return the population size.
*/
public int getPopulationSize() {
return populationSize;
}
/**
* Access the sample size.
*
* @return the sample size.
*/
public int getSampleSize() {
return sampleSize;
}
/**
* Return the highest domain value for the given hypergeometric distribution
* parameters.
*
* @param m Number of successes in the population.
* @param k Sample size.
* @return the highest domain value of the hypergeometric distribution.
*/
private int getUpperDomain(int m, int k) {
return FastMath.min(k, m);
}
/** {@inheritDoc} */
public double probability(int x) {
double ret;
int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
if (x < domain[0] || x > domain[1]) {
ret = 0.0;
} else {
double p = (double) sampleSize / (double) populationSize;
double q = (double) (populationSize - sampleSize) / (double) populationSize;
double p1 = SaddlePointExpansion.logBinomialProbability(x,
numberOfSuccesses, p, q);
double p2 =
SaddlePointExpansion.logBinomialProbability(sampleSize - x,
populationSize - numberOfSuccesses, p, q);
double p3 =
SaddlePointExpansion.logBinomialProbability(sampleSize, populationSize, p, q);
ret = FastMath.exp(p1 + p2 - p3);
}
return ret;
}
/**
* For this distribution, {@code X}, this method returns {@code P(X >= x)}.
*
* @param x Value at which the CDF is evaluated.
* @return the upper tail CDF for this distribution.
* @since 1.1
*/
public double upperCumulativeProbability(int x) {
double ret;
final int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
if (x <= domain[0]) {
ret = 1.0;
} else if (x > domain[1]) {
ret = 0.0;
} else {
ret = innerCumulativeProbability(domain[1], x, -1);
}
return ret;
}
/**
* For this distribution, {@code X}, this method returns
* {@code P(x0 <= X <= x1)}.
* This probability is computed by summing the point probabilities for the
* values {@code x0, x0 + 1, x0 + 2, ..., x1}, in the order directed by
* {@code dx}.
*
* @param x0 Inclusive lower bound.
* @param x1 Inclusive upper bound.
* @param dx Direction of summation (1 indicates summing from x0 to x1, and
* 0 indicates summing from x1 to x0).
* @return {@code P(x0 <= X <= x1)}.
*/
private double innerCumulativeProbability(int x0, int x1, int dx) {
double ret = probability(x0);
while (x0 != x1) {
x0 += dx;
;
}
return ret;
}
/**
* {@inheritDoc}
*
* For population size {@code N}, number of successes {@code m}, and sample
* size {@code n}, the mean is {@code n * m / N}.
*/
public double getNumericalMean() {
return getSampleSize() * (getNumberOfSuccesses() / (double) getPopulationSize());
}
/**
* {@inheritDoc}
*
* For population size {@code N}, number of successes {@code m}, and sample
* size {@code n}, the variance is
* {@code [n * m * (N - n) * (N - m)] / [N^2 * (N - 1)]}.
*/
public double getNumericalVariance() {
if (!numericalVarianceIsCalculated) {
numericalVariance = calculateNumericalVariance();
numericalVarianceIsCalculated = true;
}
return numericalVariance;
}
/**
* Used by {@link #getNumericalVariance()}.
*
* @return the variance of this distribution
*/
protected double calculateNumericalVariance() {
final double N = getPopulationSize();
final double m = getNumberOfSuccesses();
final double n = getSampleSize();
return (n * m * (N - n) * (N - m)) / (N * N * (N - 1));
}
/**
* {@inheritDoc}
*
* For population size {@code N}, number of successes {@code m}, and sample
* size {@code n}, the lower bound of the support is
* {@code max(0, n + m - N)}.
*
* @return lower bound of the support
*/
public int getSupportLowerBound() {
return FastMath.max(0,
getSampleSize() + getNumberOfSuccesses() - getPopulationSize());
}
/**
* {@inheritDoc}
*
* For number of successes {@code m} and sample size {@code n}, the upper
* bound of the support is {@code min(m, n)}.
*
* @return upper bound of the support
*/
public int getSupportUpperBound() {
return FastMath.min(getNumberOfSuccesses(), getSampleSize());
}
/**
* {@inheritDoc}
*
* The support of this distribution is connected.
*
* @return {@code true}
*/
public boolean isSupportConnected() {
return true;
}
}
| [
"kesina@Kesinas-MBP.lan"
] | kesina@Kesinas-MBP.lan |
cf76ac555c47b0e7f62b5154af28a9e1bbea3da7 | 8f0095667ff410648c8ce99000c9c96229a9d57e | /src/Panels/Question8Panel.java | 0b771e87550f0efa5ceeeed2c6c4c97c59197413 | [] | no_license | rebecca-wong/AnsweringMachine | ac5774ff70cff747fc461c6c801ce573bc627a4b | bdcf5803806cec6f2e43309228fafaf800696eec | refs/heads/master | 2020-03-16T05:21:08.415823 | 2018-06-03T17:04:37 | 2018-06-03T17:04:37 | 132,530,645 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 15,331 | java | package Panels;
import java.awt.Color;
import java.awt.Font;
import java.awt.Image;
import java.awt.font.TextAttribute;
import javax.swing.*;
import javafx.scene.chart.PieChart.Data;
public class Question8Panel extends Panel {
JLabel questionLabel1;
JLabel questionLabel2;
JLabel responsesLabel;
JLabel headerQuestion1;
JLabel headerQuestion2;
JLabel browseLabel;
JLabel navigateLabel;
JLabel recordLabel;
JLabel stopLabel;
JLabel submitLabel;
JLabel deleteLabel;
JButton questionNumberButton;
ImageIcon q1Image;
JButton upArrowButton;
ImageIcon upArrowImage;
JButton downArrowButton;
ImageIcon downArrowImage;
JButton browseLineButton;
ImageIcon browseLineImage;
JButton navigateLineButton;
ImageIcon navigateLineImage;
JButton recordLineButton;
ImageIcon recordLineImage;
JButton recordButton;
ImageIcon recordImage;
JButton stopButton;
ImageIcon stopImage;
boolean bPressed;
int timesbPressed;
/*JButton browseButton;
ImageIcon browseImage;
JButton navigateButton;
ImageIcon navigateImage;
JButton recordButton;
ImageIcon recordImage;*/
public Question8Panel(JPanel screens) {
super(screens);
}
public void gui() {
///// Make labels ///////
questionLabel1 = new JLabel("\"Do you like the design major or do you ");
questionLabel2 = new JLabel("wish you chose a different major?\"");
responsesLabel = new JLabel("2 responses");
headerQuestion1 = new JLabel("Q8");
headerQuestion2 = new JLabel("OUT OF 10");
browseLabel = new JLabel("BROWSE");
navigateLabel = new JLabel("NAVIGATE");
recordLabel = new JLabel("RECORD");
stopLabel = new JLabel("STOP");
submitLabel = new JLabel("SUBMIT");
deleteLabel = new JLabel("DELETE");
bPressed = false;
timesbPressed = 0;
/////// Make Buttons /////////
//question 1 image
q1Image = new ImageIcon(this.getClass().getResource("/q1.png"));
questionNumberButton = new JButton();
questionNumberButton.setBorder(BorderFactory.createEmptyBorder());
//up arrow button. CHANGE TO UP ARROW LATER
upArrowImage = new ImageIcon(this.getClass().getResource("/Arrow_Up.png"));
upArrowButton = new JButton();
upArrowButton.setBorder(BorderFactory.createEmptyBorder());
//down arrow button.
downArrowImage = new ImageIcon(this.getClass().getResource("/Arrow_Down.png"));
downArrowButton = new JButton();
downArrowButton.setBorder(BorderFactory.createEmptyBorder());
//browse button
browseLineImage = new ImageIcon(this.getClass().getResource("/line_2.png"));
browseLineButton = new JButton();
browseLineButton.setBorder(BorderFactory.createEmptyBorder());
//Navigate button
navigateLineImage = new ImageIcon(this.getClass().getResource("/line_2.png"));
navigateLineButton = new JButton();
navigateLineButton.setBorder(BorderFactory.createEmptyBorder());
//Record button
recordLineImage = new ImageIcon(this.getClass().getResource("/line_2.png"));
recordLineButton = new JButton();
recordLineButton.setBorder(BorderFactory.createEmptyBorder());
//circle record button
recordImage = new ImageIcon(this.getClass().getResource("/Record_Button.png"));
recordButton = new JButton();
recordButton.setBorder(BorderFactory.createEmptyBorder());
stopImage = new ImageIcon(this.getClass().getResource("/Stop_Button.png"));
stopButton = new JButton();
stopButton.setBorder(BorderFactory.createEmptyBorder());
////////Add Components to this//////////
this.add(questionLabel1);
this.add(questionLabel2);
this.add(responsesLabel);
this.add(upArrowButton);
this.add(downArrowButton);
this.add(browseLineButton);
this.add(navigateLineButton);
this.add(recordLineButton);
this.add(headerQuestion1);
this.add(headerQuestion2);
this.add(browseLabel);
this.add(recordLabel);
this.add(navigateLabel);
this.add(stopLabel);
this.add(submitLabel);
this.add(recordButton);
this.add(deleteLabel);
this.add(stopButton);
this.setOptions();
}
public void shown() {
Variables.questionNumber = 8;
System.out.println(Variables.questionNumber);
}
public void setOptions() {
SpringLayout sl = (SpringLayout) this.getLayout();
/*first line of question label is 90 + mainY and second line 35 pixels further down aka + 125
* 225 pixels between buttons on the bottom*/
questionLabel1.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 30));
sl.putConstraint(SpringLayout.WEST, questionLabel1, this.mainX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, questionLabel1, this.mainY() + this.scaledY(90), SpringLayout.NORTH, this);
questionLabel2.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 30));
sl.putConstraint(SpringLayout.WEST, questionLabel2, this.mainX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, questionLabel2, this.mainY() + this.scaledY(125), SpringLayout.NORTH, this);
responsesLabel.setFont(this.customFont(TextAttribute.WEIGHT_REGULAR, 14));
sl.putConstraint(SpringLayout.WEST, responsesLabel, this.mainX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, responsesLabel, this.mainY() + this.scaledY(180), SpringLayout.NORTH, this);
headerQuestion1.setFont(this.customFont(TextAttribute.WEIGHT_REGULAR, 25));
sl.putConstraint(SpringLayout.WEST, headerQuestion1, this.mainX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, headerQuestion1, this.mainY(), SpringLayout.NORTH, this);
headerQuestion2.setFont(this.customFont(TextAttribute.WEIGHT_REGULAR, 12));
sl.putConstraint(SpringLayout.WEST, headerQuestion2, this.mainX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, headerQuestion2, this.mainY() + this.scaledY(28), SpringLayout.NORTH, this);
browseLabel.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 15));
sl.putConstraint(SpringLayout.WEST, browseLabel, this.mainX() + this.scaledX(5), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, browseLabel, this.mainY() + this.scaledY(475), SpringLayout.NORTH, this);
navigateLabel.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 15));
sl.putConstraint(SpringLayout.WEST, navigateLabel, this.mainX() + this.scaledX(227), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, navigateLabel, this.mainY() + this.scaledY(475), SpringLayout.NORTH, this);
recordLabel.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 15));
sl.putConstraint(SpringLayout.WEST, recordLabel, this.mainX() + this.scaledX(455), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, recordLabel, this.mainY() + this.scaledY(475), SpringLayout.NORTH, this);
stopLabel.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 15));
stopLabel.setVisible(false);
sl.putConstraint(SpringLayout.WEST, stopLabel, this.mainX() + this.scaledX(465), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, stopLabel, this.mainY() + this.scaledY(475), SpringLayout.NORTH, this);
submitLabel.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 15));
submitLabel.setVisible(false);
sl.putConstraint(SpringLayout.WEST, submitLabel, this.mainX() + this.scaledX(455), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, submitLabel, this.mainY() + this.scaledY(475), SpringLayout.NORTH, this);
deleteLabel.setFont(this.customFont(TextAttribute.WEIGHT_BOLD, 15));
deleteLabel.setVisible(false);
sl.putConstraint(SpringLayout.WEST, deleteLabel, this.mainX() + this.scaledX(5), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, deleteLabel, this.mainY() + this.scaledY(475), SpringLayout.NORTH, this);
//sl.putConstraint(SpringLayout.WEST, questionNumberButton, this.mainX(), SpringLayout.WEST, this);
// sl.putConstraint(SpringLayout.NORTH, questionNumberButton, this.mainY(), SpringLayout.NORTH, this);
sl.putConstraint(SpringLayout.WEST, upArrowButton, this.leftX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, upArrowButton, this.leftY(), SpringLayout.NORTH, this);
sl.putConstraint(SpringLayout.WEST, downArrowButton, this.leftX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, downArrowButton, this.leftY() + this.scaledY(400), SpringLayout.NORTH, this);
sl.putConstraint(SpringLayout.WEST, browseLineButton, this.mainX(), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, browseLineButton, 0, SpringLayout.SOUTH, this);
sl.putConstraint(SpringLayout.WEST, navigateLineButton, this.mainX() + this.scaledX(225), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, navigateLineButton, 0, SpringLayout.SOUTH, this);
sl.putConstraint(SpringLayout.WEST, recordLineButton, this.mainX() + this.scaledX(450), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.SOUTH, recordLineButton, 0, SpringLayout.SOUTH, this);
recordButton.setVisible(false);
sl.putConstraint(SpringLayout.WEST, recordButton,this.mainX() + this.scaledX(205), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, recordButton, this.mainY() + this.scaledY(190), SpringLayout.NORTH, this);
stopButton.setVisible(false);
sl.putConstraint(SpringLayout.WEST, stopButton,this.mainX() + this.scaledX(205), SpringLayout.WEST, this);
sl.putConstraint(SpringLayout.NORTH, stopButton, this.mainY() + this.scaledY(190), SpringLayout.NORTH, this);
Image img = q1Image.getImage() ;
Image newimg = img.getScaledInstance(this.scaledY(150), this.scaledY(50), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon q1Image = new ImageIcon( newimg );
questionNumberButton.setIcon(q1Image);
Image upImg = upArrowImage.getImage() ;
Image newUpImg = upImg.getScaledInstance(this.scaledY(20), this.scaledY(50), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon upArrowIcon = new ImageIcon( newUpImg );
upArrowButton.setIcon(upArrowIcon);
Image downImg = downArrowImage.getImage() ;
Image newDownImg = downImg.getScaledInstance(this.scaledY(20), this.scaledY(50), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon downArrowIcon = new ImageIcon( newDownImg );
downArrowButton.setIcon(downArrowIcon);
Image browseImg = browseLineImage.getImage() ;
Image newBrowseImg = browseImg.getScaledInstance(this.scaledY(65), this.scaledY(50), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon browseIcon = new ImageIcon( newBrowseImg );
browseLineButton.setIcon(browseIcon);
Image navigateImg = navigateLineImage.getImage() ;
Image newNavigateImg = navigateImg.getScaledInstance(this.scaledY(65), this.scaledY(50), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon navigateIcon = new ImageIcon( newNavigateImg);
navigateLineButton.setIcon(navigateIcon);
Image recordImg = recordLineImage.getImage() ;
Image newRecordImg = recordImg.getScaledInstance(this.scaledY(65), this.scaledY(50), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon recordIcon = new ImageIcon( newRecordImg );
recordLineButton.setIcon(recordIcon);
Image recordCircleImg = recordImage.getImage() ;
Image newRecordCircleImg = recordCircleImg.getScaledInstance(this.scaledY(100), this.scaledY(100), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon recordCircleIcon = new ImageIcon( newRecordCircleImg );
recordButton.setIcon(recordCircleIcon);
Image stopImg = stopImage.getImage() ;
Image newStopImg = stopImg.getScaledInstance(this.scaledY(100), this.scaledY(100), java.awt.Image.SCALE_SMOOTH ) ;
ImageIcon stopIcon = new ImageIcon( newStopImg );
stopButton.setIcon(stopIcon);
}
public void PressedUp() {
if(timesbPressed == 0) {
showScreen(Panel.QUESTION7_PANEL);
}
}
public void PressedDown() {
if(timesbPressed == 0) {
showScreen(Panel.QUESTION9_PANEL);
}
}
public void PressedA() {
if(timesbPressed == 0) {
showScreen(Panel.BROWSEP1_1PANEL);
} else {
upArrowButton.setVisible(true);
downArrowButton.setVisible(true);
browseLineButton.setVisible(true);
navigateLineButton.setVisible(true);
browseLabel.setVisible(true);
navigateLabel.setVisible(true);
recordLabel.setVisible(true);
responsesLabel.setVisible(true);
stopLabel.setVisible(false);
stopButton.setVisible(false);
submitLabel.setVisible(false);
deleteLabel.setVisible(false);
headerQuestion1.setForeground(new Color(0f, 0f, 0f, 1f));
headerQuestion2.setForeground(new Color(0f, 0f, 0f, 1f));
questionLabel1.setForeground(new Color(0f, 0f, 0f, 1f));
questionLabel2.setForeground(new Color(0f, 0f, 0f, 1f));
showScreen(Panel.MAYBE_DELETE_PANEL);
timesbPressed = 0;
}
}
public void PressedB() {
//record is pressed
if(timesbPressed == 0) {
timesbPressed = 1;
upArrowButton.setVisible(false);
downArrowButton.setVisible(false);
browseLineButton.setVisible(false);
navigateLineButton.setVisible(false);
browseLabel.setVisible(false);
navigateLabel.setVisible(false);
recordLabel.setVisible(false);
stopLabel.setVisible(true);
recordButton.setVisible(true);
responsesLabel.setVisible(false);
headerQuestion1.setForeground(new Color(0f, 0f, 0f, 0.2f));
headerQuestion2.setForeground(new Color(0f, 0f, 0f, 0.2f));
questionLabel1.setForeground(new Color(0f, 0f, 0f, 0.2f));
questionLabel2.setForeground(new Color(0f, 0f, 0f, 0.2f));
//hannah's recording method
//stop is pressed
} else if (timesbPressed == 1) {
timesbPressed = 2;
stopLabel.setVisible(false);
deleteLabel.setVisible(true);
browseLineButton.setVisible(true);
recordButton.setVisible(false);
stopButton.setVisible(true);
submitLabel.setVisible(true);
//submit is pressed
} else if (timesbPressed == 2) {
timesbPressed = 0;
upArrowButton.setVisible(true);
downArrowButton.setVisible(true);
browseLineButton.setVisible(true);
navigateLineButton.setVisible(true);
browseLabel.setVisible(true);
navigateLabel.setVisible(true);
recordLabel.setVisible(true);
responsesLabel.setVisible(true);
stopLabel.setVisible(false);
stopButton.setVisible(false);
submitLabel.setVisible(false);
deleteLabel.setVisible(false);
headerQuestion1.setForeground(new Color(0f, 0f, 0f, 1f));
headerQuestion2.setForeground(new Color(0f, 0f, 0f, 1f));
questionLabel1.setForeground(new Color(0f, 0f, 0f, 1f));
questionLabel2.setForeground(new Color(0f, 0f, 0f, 1f));
showScreen(Panel.THANK_YOU_PANEL);
}
//showScreen(Panel.Q1_RECORD_PANEL);
}
} | [
"RebeccaWong@d-10-19-122-54.dhcp4.washington.edu"
] | RebeccaWong@d-10-19-122-54.dhcp4.washington.edu |
a4d969ea53b5a50f0aeb951597ad123e8fe4a7bb | 135515706bf50d8c7a62c8bec003c1fed1562217 | /CodingInterviews/src/sortingAndSearching/ctci/Q2/SortArrayByAnagrams.java | 8b3be6d988145c342b2421ac11d444279047b57c | [] | no_license | schaefce/interviews | 1d690aac82ab100c479f45554b71021c1e797c6d | 63a19cd50e7c20d4d20c5cda19eee9d6115ec9bf | refs/heads/master | 2016-09-06T15:26:10.791961 | 2014-10-10T21:58:19 | 2014-10-10T21:58:19 | 23,842,103 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 1,514 | java | package sortingAndSearching.ctci.Q2;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
public class SortArrayByAnagrams {
public static void sort(String[] strings) {
HashMap<String, LinkedList<String>> hashGrams = new HashMap<String, LinkedList<String>>();
for (String s : strings) {
char[] chars = s.toCharArray();
Arrays.sort(chars);
String sorted = new String(chars);
if (hashGrams.get(sorted) == null) {
LinkedList<String> anagrams = new LinkedList<String>();
anagrams.add(s);
hashGrams.put(sorted, anagrams);
} else {
LinkedList<String> anagrams = hashGrams.get(sorted);
anagrams.add(s);
}
}
int i = 0;
for (String s : hashGrams.keySet()) {
LinkedList<String> anagrams = hashGrams.get(s);
for (String t : anagrams) {
strings[i] = t;
i++;
}
}
}
public static void main(String[] args) {
String[] strings = new String[8];
strings[0] = "CAT";
strings[1] = "WAS";
strings[2] = "TEAR";
strings[3] = "SAW";
strings[4] = "TIME";
strings[5] = "MITE";
strings[6] = "SHARE";
strings[7] = "RATE";
System.out.println(Arrays.toString(strings));
sort(strings);
System.out.println(Arrays.toString(strings));
}
}
| [
"schaefce@miamioh.edu"
] | schaefce@miamioh.edu |
d9e64c9eb7ff0bfb66d226bbd8dd0f7e32d16786 | d3c825c7dc3c989b81b18dffda04415b523fac8f | /servicenow/src/com/wipro/automation/snow/lib/Crypto.java | f208b757d630c45ec51f74b5855a570446ce663b | [] | no_license | ashin4droid/test | 2656266d74035d9473f35d989e93039bfeef3e7e | 49f8a81528bd00e2d44e60c0699e10ae7415545a | refs/heads/master | 2020-03-25T04:24:03.191293 | 2018-08-15T14:53:11 | 2018-08-15T14:53:11 | 143,392,845 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,035 | java | package com.wipro.automation.snow.lib;
import java.security.Key;
import java.util.Base64;
import java.util.Scanner;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
/*import Decoder.BASE64Decoder;
import Decoder.BASE64Encoder;
*/
public class Crypto
{
private static final String ALGORITHM = "AES";
private static final String KEY = "4~WfjW$h37^rK4dJ";
public static String encrypt(String value) throws Exception
{
Key key = generateKey();
Cipher cipher = Cipher.getInstance(Crypto.ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
byte [] encryptedByteValue = cipher.doFinal(value.getBytes("utf-8"));
//String encryptedValue64 = new BASE64Encoder().encode(encryptedByteValue);
String encryptedValue64 = Base64.getEncoder().encodeToString(encryptedByteValue);
return encryptedValue64;
}
public static String decrypt(String value) throws Exception
{
Key key = generateKey();
Cipher cipher = Cipher.getInstance(Crypto.ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
//byte [] decryptedValue64 = new BASE64Decoder().decodeBuffer(value);
byte [] decryptedValue64 = Base64.getDecoder().decode(value);
byte [] decryptedByteValue = cipher.doFinal(decryptedValue64);
String decryptedValue = new String(decryptedByteValue,"utf-8");
return decryptedValue;
}
public static Key generateKey() throws Exception
{
Key key = new SecretKeySpec(Crypto.KEY.getBytes(), Crypto.ALGORITHM);
return key;
}
public static String getString(String encString)
{
byte [] barr = Base64.getDecoder().decode(encString);
return new String(barr);
}
public static void main(String[] args) throws Exception
{
String scan;
Scanner s = new Scanner(System.in);
System.out.print("Enter the value to be encrypted : ");
scan = s.next();
s.close();
//System.out.println("Encrypted value is : " + Crypto.encrypt(pass));
System.out.println("Encrypted value is : " + Crypto.encrypt(scan));
}
} | [
"AS762939@L-156153676.wipro.com"
] | AS762939@L-156153676.wipro.com |
ad01e20155de0e1fb1d6f94f08ea0e8fae618c41 | 6d6463ec34aaf362d191ae88f351e236492751b2 | /app/src/main/java/com/cretin/www/caipu/eventbus/NotifyRegisterOrLoginSuccess.java | c0f9e54fbde7704fa5f6e96306c71089139ee84b | [] | no_license | MZCretin/Caipu1 | 7a360ad2f571b3ba4a707b58bced4693a52bd192 | 2402215fdf87dbadc5e171d24d30116e566bbe68 | refs/heads/master | 2021-01-22T19:31:08.070143 | 2017-03-21T13:36:14 | 2017-03-21T13:36:14 | 85,207,165 | 5 | 0 | null | null | null | null | UTF-8 | Java | false | false | 129 | java | package com.cretin.www.caipu.eventbus;
/**
* Created by cretin on 2017/1/5.
*/
public class NotifyRegisterOrLoginSuccess {
}
| [
"mxnzp_life@163.com"
] | mxnzp_life@163.com |
d5132bccc495b0ce9e4d329caaaa62151c0a4979 | 3b37c5c557ed6d2d2b0e10f4fcf5445f772bbaab | /src/edu/neu/madcourse/zhongjiemao/gsonhelper/entities/OnLineUser.java | daa1c9289425fb4adb142f40fae50c5a084143a3 | [] | no_license | zhongjieM/NUMAD | 182e59fd91f72dc10596e9ad78341ed0cfd51cfa | 1897d0316fb70f708ad4d4b67b0ee1b0a0c50468 | refs/heads/master | 2021-01-19T17:41:44.408381 | 2013-04-21T03:29:15 | 2013-04-21T03:29:15 | 31,503,210 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,359 | java | package edu.neu.madcourse.zhongjiemao.gsonhelper.entities;
/**
* An object of this class is an entity of a user who is online now. This class
* contains the user's name, user's status: already in a game or not, and the
* inviter to this user.
*
* When a user gets online, an object of this class will be generated as an
* entity of this user. When a user log off, his related object of this class
* will be cleared.
*
* @author kevin
*
*/
public class OnLineUser {
public final static String DEFAULT_INIVITER = "###";
public final static String LOCK_INIVATION = "@@@";
// userName is a String, representing the user's user name who is just
// getting online this value is correspondent to the userID member of
// UserInfo class
private String userName;
// inGame is a Boolean, representing whether this online user is already in
// a room or not. If inGame is TRUE, then other players can't send him
// invitations any more.
private Boolean inGame;
// inviter is a String, representing the inviter player's user name which is
// corresponding to the user user name member of UserInfo class.
// If there are many other players send this player invitation, only the
// latest invitation will be shown to this user.
private String inviter;
/**
* Default Constructor
*/
public OnLineUser() {
}
/**
* Constructor with parameters to initialize all the members of this class.
*
* @param uid
* @param ig
* @param intor
*/
public OnLineUser(String uid, Boolean ig, String intor) {
this.userName = uid;
this.inGame = ig;
this.inviter = intor;
}
// getters and setters of all the members of this class
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Boolean getInGame() {
return inGame;
}
public void setInGame(Boolean inGame) {
this.inGame = inGame;
}
public String getInviter() {
return inviter;
}
public void setInviter(String inviter) {
this.inviter = inviter;
}
@Override
/**
* -> String
* Purpose Statement: return all the values of this online user in String formation.
* Strategy: Domain Knowledge
*/
public String toString() {
return "Online Player: " + this.userName + ", " + "In Game?: "
+ this.inGame + ", " + "Latest Inviter: " + this.inviter
+ " |OVER|";
}
}
| [
"mao.z@husky.neu.edu"
] | mao.z@husky.neu.edu |
f6f5378bf45238a40cb1147ac3afaf846fde8f1c | eab084584e34ec065cd115139c346180e651c1c2 | /src/test/java/v1/t1200/T1282Test.java | c4f3d62b6ab1ac931a72f9a363ef126aff90f305 | [] | no_license | zhouyuan93/leetcode | 5396bd3a01ed0f127553e1e175bb1f725d1c7919 | cc247bc990ad4d5aa802fc7a18a38dd46ed40a7b | refs/heads/master | 2023-05-11T19:11:09.322348 | 2023-05-05T09:12:53 | 2023-05-05T09:12:53 | 197,735,845 | 0 | 0 | null | 2020-04-05T09:17:34 | 2019-07-19T08:38:17 | Java | UTF-8 | Java | false | false | 460 | java | package v1.t1200;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
class T1282Test {
T1282 t;
@BeforeEach
void setUp() {
t = new T1282();
}
@Test
void test_1() {
int[] groupSizes = {3, 3, 3, 3, 3, 1, 3};
List<List<Integer>> actual = t.groupThePeople(groupSizes);
System.out.println(actual);
}
} | [
"492407250@qq.com"
] | 492407250@qq.com |
e40e05661edc3e80f508ed4f1005429aba1996dc | caa6f966317a89b7a49565f048aa3bd12d3f879f | /fbreader/src/org/geometerplus/android/fbreader/libraryService/LibraryService.java | 1285fc65e8b535014a6e169c045ec403b296a131 | [] | no_license | shiwoa/ShiYouApp | 2a4587ab044c594440a91a29c2998fabc9635e48 | a327820a49a9a1f0d867090d5e8043060cbce8f5 | refs/heads/master | 2021-05-14T11:28:53.257301 | 2018-01-23T07:40:07 | 2018-01-23T07:41:08 | 116,378,144 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,046 | java | /*
* Copyright (C) 2010-2012 Geometer Plus <contact@geometerplus.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
package org.geometerplus.android.fbreader.libraryService;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import org.geometerplus.android.fbreader.library.SQLiteBooksDatabase;
import org.geometerplus.fbreader.library.AbstractLibrary;
import org.geometerplus.fbreader.library.BooksDatabase;
import org.geometerplus.fbreader.library.Library;
public class LibraryService extends Service implements Library.ChangeListener {
private LibraryImplementation myLibrary;
@Override
public void onStart(Intent intent, int startId) {
onStartCommand(intent, 0, startId);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
System.err.println("LibraryService started for intent " + intent);
return START_STICKY;
}
@Override
public IBinder onBind(Intent intent) {
System.err.println("LibraryService binded for intent " + intent);
return myLibrary;
}
@Override
public void onCreate() {
System.err.println("LibraryService.onCreate()");
super.onCreate();
myLibrary = new LibraryImplementation();
myLibrary.myBaseLibrary.addChangeListener(this);
}
@Override
public void onDestroy() {
System.err.println("LibraryService.onDestroy()");
myLibrary.myBaseLibrary.removeChangeListener(this);
myLibrary = null;
super.onDestroy();
}
public void onLibraryChanged(final Code code) {
// TODO: implement signal sending
System.err.println("LibraryService.onLibraryChanged(" + code + "): " + myLibrary.isUpToDate());
}
public final class LibraryImplementation extends LibraryInterface.Stub {
private final AbstractLibrary myBaseLibrary;
LibraryImplementation() {
BooksDatabase database = SQLiteBooksDatabase.Instance();
if (database == null) {
database = new SQLiteBooksDatabase(LibraryService.this, "LIBRARY SERVICE");
}
myBaseLibrary = new Library(database);
((Library) myBaseLibrary).startBuild();
}
public boolean isUpToDate() {
return myBaseLibrary.isUpToDate();
}
}
}
| [
"1393980938@qq.com"
] | 1393980938@qq.com |
fa9a594298873d7591efd50d6694de70c75ac896 | 97c1941ae7940d392a37d160527d36c2547c1c93 | /App/Represent/wear/src/main/java/com/example/kyle/represent/RepActivity.java | b97224a063cac92e28a39d1f79b056e8777c28ba | [] | no_license | cs160-berkeley/prog-02-represent-kyletliang | f01c8e071daff9e767c26fd2933c1ef8548d1721 | dac65b488d8f76f2ff6760e19354bf82d9547c94 | refs/heads/master | 2021-01-17T20:20:35.405496 | 2016-03-14T05:29:06 | 2016-03-14T05:29:06 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,897 | java | package com.example.kyle.represent;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.wearable.view.DotsPageIndicator;
import android.support.wearable.view.GridViewPager;
import android.support.wearable.view.WatchViewStub;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.wearable.Wearable;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
public class RepActivity extends Activity implements SensorEventListener {
private TextView mTextView;
private String zip;
private String info;
private String[] infoArray, repArray, voteArray;
private Page[][] data = new Page[2][];
private SensorManager senSensorManager;
private Sensor senAccelerometer;
private long lastUpdate = 0;
private float mLastX, mLastY, mLastZ;
private boolean mInitialized;
private final float NOISE = (float) 2.0;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rep);
Intent intent = getIntent();
info = intent.getStringExtra("INFO_WATCH");
infoArray = info.split("//");
repArray = infoArray[0].split("!");
voteArray = infoArray[1].split("!");
setupPageInfo();
final DotsPageIndicator mPageIndicator = (DotsPageIndicator) findViewById(R.id.page_indicator);
final GridViewPager pager = (GridViewPager) findViewById(R.id.pager);
pager.setAdapter(new SampleGridPagerAdapter(this, data, getFragmentManager()));
mPageIndicator.setPager(pager);
senSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
senAccelerometer = senSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
senSensorManager.registerListener(this, senAccelerometer , SensorManager.SENSOR_DELAY_NORMAL);
}
@Override
protected void onPause() {
super.onPause();
senSensorManager.unregisterListener(this);
}
@Override
protected void onResume() {
super.onResume();
senSensorManager.registerListener(this, senAccelerometer, SensorManager.SENSOR_DELAY_NORMAL);
}
private void setupPageInfo(){
data[0] = new Page[repArray.length/2+1];
data[1] = new Page[1];
String county;
if (voteArray[0] == null)
county = "Unknown County (Try shaking again)";
else
county = voteArray[0];
int bg;
if(Double.parseDouble(voteArray[1])>= Double.parseDouble(voteArray[2]))
bg = R.drawable.bluebg;
else
bg = R.drawable.redbg;
for(int i = 0; i < repArray.length/2; i+=1){
if (repArray[2*i+1].equals("D")) {
data[0][i+1] = new Page(repArray[2 * i], "Democrat", county, R.drawable.bluebg, true);
}
else if(repArray[2*i+1].equals("R")){
data[0][i+1] = new Page(repArray[2 * i],"Republican", county, R.drawable.redbg, true);
}
else{
data[0][i+1] = new Page(repArray[2 * i],"Independent", county, R.drawable.indep, true);
}
}
data[0][0] = new Page(voteArray[1], voteArray[2], county, bg, false);
data[1][0] = new Page(voteArray[1], voteArray[2], county, bg, false);
}
@Override
public void onSensorChanged(SensorEvent event) {
float x = event.values[0];
float y = event.values[1];
float z = event.values[2];
if (!mInitialized) {
mLastX = x;
mLastY = y;
mLastZ = z;
mInitialized = true;
} else {
float deltaX = Math.abs(mLastX - x);
float deltaY = Math.abs(mLastY - y);
float deltaZ = Math.abs(mLastZ - z);
if (deltaX < NOISE) deltaX = (float) 0.0;
if (deltaY < NOISE) deltaY = (float) 0.0;
if (deltaZ < NOISE) deltaZ = (float) 0.0;
mLastX = x;
mLastY = y;
mLastZ = z;
if ((deltaX + deltaY + deltaZ) > (float) 50){
int range = (43583 - 2) + 1;
int rand = (int)(Math.random() * range) + 1; //randomly generated number to be zip
Intent sendIntent = new Intent(getBaseContext(), WatchToPhoneService.class);
sendIntent.putExtra("RAND", Integer.toString(rand));
startService(sendIntent);
}
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {}
public static class Page {
String rep;
String county;
String party;
String obamaVote;
String romneyVote;
int mImageResource;
public Page(String s1, String s2, String c, int im, boolean isRep){
if(isRep) {
rep = s1;
party = s2;
}
else{
obamaVote = s1;
romneyVote = s2;
}
mImageResource = im;
county = c;
}
}
}
| [
"kyletliang@gmail.com"
] | kyletliang@gmail.com |
9ef5db4a2b02fa70921855c8f9187a104b4fdd6d | 8d1014a3800ec0163bdbae78fc55a466fec64715 | /workspace/shop/src/view/ReturnManagerView.java | 1275fdbc466fb1c00072a2aeb45917f44de93d4d | [] | no_license | Geend/FHDWGojaShop | 23c186a625b141a90f1599f8a24c34ad0c9676f8 | 1701caa7fa0e76d9b3ef77f2904d2f04bb77da65 | refs/heads/master | 2021-06-08T14:08:05.356702 | 2016-12-12T19:19:07 | 2016-12-12T19:19:07 | 72,030,711 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 742 | java | package view;
import view.objects.*;
import view.visitor.*;
public interface ReturnManagerView extends Anything, AbstractViewRoot {
public java.util.Vector<ArticleReturnView> getArticleReturn()throws ModelException;
public void setArticleReturn(java.util.Vector<ArticleReturnView> newValue) throws ModelException ;
public void accept(AnythingVisitor visitor) throws ModelException;
public <R> R accept(AnythingReturnVisitor<R> visitor) throws ModelException;
public <E extends view.UserException> void accept(AnythingExceptionVisitor<E> visitor) throws ModelException, E;
public <R, E extends view.UserException> R accept(AnythingReturnExceptionVisitor<R, E> visitor) throws ModelException, E;
}
| [
"git@t-voltmer.net"
] | git@t-voltmer.net |
409c9264019af8a294184fe73b25b2f9b8f1ef0d | ac083d27c22b39a42063d14a85f1b62840fe6cff | /cdv-server/pdata-source-connectors/src/main/java/it/eng/opsi/cdv/pdatasourceconnectors/model/PDataEntry.java | 8c1a77f98536dfb678bd2a1a6709d71b3909aa70 | [
"MIT"
] | permissive | SIMPATICOProject/CDV | e89ca895f8df6dcc19503633c16e04382bfa9ad2 | 7c147651886abfae85dd12ed62ed3dd22d87e3ba | refs/heads/master | 2021-01-19T09:17:46.155332 | 2019-04-19T10:43:12 | 2019-04-19T10:43:12 | 82,092,159 | 0 | 1 | MIT | 2018-09-17T14:04:35 | 2017-02-15T18:25:51 | Java | UTF-8 | Java | false | false | 4,402 | java | /*******************************************************************************
* The MIT License (MIT)
* Copyright (c) 2016, 2018 Engineering Ingegneria Informatica S.p.A
*
* 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 it.eng.opsi.cdv.pdatasourceconnectors.model;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.List;
public class PDataEntry {
// @JsonRequired
private String name;
// @JsonRequired
private String conceptId;
private ZonedDateTime timestamp;
private String type = "http://www.w3.org/2001/XMLSchema#string";
// PUT HERE ADDITIONAL PROPERTIES; BEFORE VALUES PROPERTY !!!
/*
* TODO IMPORTANT: This property must be the last one of the class, due to the
* CSV logic of PDataExporter
*/
private List<String> values;
/* *********************** */
public PDataEntry() {
this.timestamp = ZonedDateTime.now(ZoneOffset.UTC);
}
public PDataEntry(String conceptId, String name, String type, List<String> values, String accountId) {
this.name = name;
this.conceptId = conceptId;
this.type = type;
this.values = values;
this.timestamp = ZonedDateTime.now(ZoneOffset.UTC);
}
public PDataEntry(String conceptId, String name, String type, ArrayList<String> values, ZonedDateTime timestamp,
String accountId) {
this.name = name;
this.conceptId = conceptId;
this.type = type;
this.values = values;
this.timestamp = timestamp;
}
public PDataEntry(String conceptId, String name, String type, String accountId) {
this.name = name;
this.conceptId = conceptId;
this.type = type;
this.values = new ArrayList<String>();
this.timestamp = ZonedDateTime.ofInstant(Instant.now(), ZoneId.of("Z"));
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getConceptId() {
return conceptId;
}
public void setConceptId(String conceptID) {
this.conceptId = conceptID;
}
public ZonedDateTime getTimestamp() {
return timestamp;
}
public void setTimestamp(ZonedDateTime timestamp) {
this.timestamp = timestamp;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public List<String> getValues() {
return values;
}
public void setValues(List<String> values) {
this.values = values;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("class PData {\n");
sb.append(" conceptId: ").append(toIndentedString(conceptId)).append("\n");
sb.append(" name: ").append(toIndentedString(name)).append("\n");
sb.append(" type: ").append(toIndentedString(type)).append("\n");
sb.append(" values: [\n ");
values.stream().forEach(value -> sb.append(" " + toIndentedString(value)).append("\n"));
sb.append(toIndentedString(" ]\n"));
sb.append("timestamp: ").append(toIndentedString(timestamp)).append("\n");
sb.append("}");
return sb.toString();
}
/**
* Convert the given object to string with each line indented by 4 spaces
* (except the first line).
*/
private String toIndentedString(Object o) {
if (o == null) {
return "null";
}
return o.toString().replace("\n", "\n ");
}
}
| [
"savarino"
] | savarino |
df8a4852edc253274bcfa7980bb03020f14c50d8 | 908202e6167f42a65056f64120a5646de619fca4 | /Novo-Inpire-G/src/main/java/com/example/demo/services/OfertaService.java | 51473892606b0913646b7922bcb5dfe12fe9813d | [] | no_license | besoftwareifpe/InspireGourmet1 | d67491bc96493f38615f8500c3e96dc1b12c74f1 | 47dc0f41d4272cb7d595e7f98fe65b5229f125fc | refs/heads/master | 2020-09-25T08:10:55.546660 | 2020-02-02T19:32:31 | 2020-02-02T19:32:31 | 225,958,704 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 757 | java | package com.example.demo.services;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.demo.daos.OfertaDAO;
import com.example.demo.models.Oferta;
@Service
public class OfertaService {
@Autowired
private OfertaDAO repository;
public void save(Oferta oferta) {
repository.save(oferta);
}
public Oferta get(Integer idRestaurante) {
return repository.buscaOferta(idRestaurante);
}
public Oferta buscarPeloId(Integer idOferta) {
return repository.findById(idOferta).get();
}
public void delete(Integer idRestaurante) {
repository.deleteById(idRestaurante);
}
public void buscarPorIdRest(Integer idRest) {
repository.deletePorIdRest(idRest);
}
}
| [
"clebsonjose30@gmail.com"
] | clebsonjose30@gmail.com |
afe68168c8127f57bb8865030ada42cc94e834a7 | 2c69724e8f42d1589f1e3ea796ed1a8744ae1a0b | /src/test/java/com/github/seriybg/junit/easytools/model/internal/TestObjectTest.java | 57363f9670a384b7475d0eb0ab0d8caf1dc2f0eb | [
"MIT"
] | permissive | SeriyBg/junit-easy-tools | 93c2dd7bdb00cd02cefe5524550c30d2f1f9b482 | ea3ae0c4745395d48fdefdcae2d198a8204cd34e | refs/heads/master | 2020-04-02T01:44:40.560651 | 2017-10-18T10:04:56 | 2017-10-18T10:04:56 | 83,407,850 | 3 | 2 | null | 2017-10-18T10:04:57 | 2017-02-28T08:22:32 | Java | UTF-8 | Java | false | false | 2,222 | java | package com.github.seriybg.junit.easytools.model.internal;
import com.github.seriybg.junit.easytools.model.annotation.TestFactory;
import org.junit.Test;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.TestClass;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* @author Serge Bishyr
*/
public class TestObjectTest {
private static class ClassWithFactoryMethod{
private final String injected;
private ClassWithFactoryMethod(String injected) {
this.injected = injected;
}
@TestFactory
public static ClassWithFactoryMethod factory() {
return new ClassWithFactoryMethod("injected");
}
}
@Test
public void shouldCreateObjectUsingFactoryMethod() throws Exception {
TestClass testClass = new TestClass(ClassWithFactoryMethod.class);
TestObject testObject = new TestObject(testClass);
Object result = testObject.createTestObject();
assertThat(result).isInstanceOf(ClassWithFactoryMethod.class);
assertThat(((ClassWithFactoryMethod)result).injected).isEqualTo("injected");
}
private static class WrongFactoryType {
@TestFactory
public static String factory() {
throw new AssertionError("Should no be called");
}
}
@Test
public void shouldThrowExceptionOnWrongTypeOfFactory() throws Exception {
TestClass testClass = new TestClass(WrongFactoryType.class);
assertThatExceptionOfType(InitializationError.class)
.isThrownBy(() -> new TestObject(testClass).createTestObject());
}
private static class NotStaticFactoryMethod {
@TestFactory
public NotStaticFactoryMethod factoryMethod() {
return new NotStaticFactoryMethod();
}
}
@Test
public void shouldValidateFactoryMethodIsStatic() throws Exception {
TestClass testClass = new TestClass(NotStaticFactoryMethod.class);
assertThatExceptionOfType(InitializationError.class)
.isThrownBy(() -> new TestObject(testClass).createTestObject());
}
} | [
"seriybg@gmail.com"
] | seriybg@gmail.com |
05695d6dc3c271ab213dc5ddfde83eb46fd955f2 | 0b6abbfe43e30db53a5d18f918a8e56e27d8af75 | /src/binary_search_tree/PrintTree_1.java | 2c0a0f432df117bfa186ce00a86fe23b3e45884e | [] | no_license | labulakaupppppp/Code100Days | 5e560e6dfa7c006023226aff399686f887c661f4 | ecc76accc499546006acda8d49d9f8bf81ad9759 | refs/heads/master | 2020-03-23T10:37:37.660120 | 2018-11-01T02:53:03 | 2018-11-01T02:53:03 | 141,237,648 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,821 | java | package binary_search_tree;
import java.util.Stack;
import structure.TreeNode;
public class PrintTree_1 {
public static void main(String[] args) {
TreeNode head = new TreeNode(1);
TreeNode h1 = new TreeNode(2);
TreeNode h2 = new TreeNode(3);
TreeNode h3 = new TreeNode(4);
TreeNode h4 = new TreeNode(5);
head.left = h1;
head.right = h2;
h1.left = h3;
h1.right = h4;
h2.left = null;
h2.right = null;
h3.left = null;
h3.right = null;
h4.left = null;
h4.right = null;
System.out.println("递归的先序遍历");
preOrderRecur(head);
System.out.println();
System.out.println("非递归的先序遍历");
preOrderUnRecur(head);
System.out.println("递归的中序遍历");
inOrderRecur(head);
System.out.println();
System.out.println("非递归的中序遍历");
inOrderUnRecur(head);
System.out.println("递归的后序遍历");
posOrderRecur(head);
System.out.println();
System.out.println("非递归的后序遍历");
posOrderUnRecur2(head);
System.out.println();
}
private static void posOrderUnRecur(TreeNode head) {
Stack<TreeNode> stack1 = new Stack<TreeNode>();
Stack<TreeNode> stack2 = new Stack<TreeNode>();
TreeNode cur = head;
stack1.push(cur);
while (!stack1.isEmpty()) {
TreeNode temp = stack1.pop();
stack2.push(temp);
if (temp.left != null)
stack1.push(temp.left);
if (temp.right != null) {
stack1.push(temp.right);
}
}
while (!stack2.isEmpty()) {
System.out.print(stack2.pop().val + " ");
}
}
/**
* 后序遍历的非递归：使用一个栈以及两个变量 ;h代表最后一次弹出并打印的节点
*
*/
private static void posOrderUnRecur2(TreeNode head) {
System.out.println("pos order: one stack");
if (head != null) {
Stack<TreeNode> stack = new Stack<>();
TreeNode cur =null;
stack.push(head);
while(!stack.isEmpty()) {
cur=stack.peek();
if(cur.left!=null && head!=cur.left && head!=cur.right) {
stack.push(cur.left);
}else if(cur.right!=null && head!=cur.right) {
stack.push(cur.right);
}else {
System.out.print(stack.pop().val+" ");
head=cur;
}
}
}
}
private static void inOrderUnRecur(TreeNode head) {
if (head != null) {
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = head;
while (!stack.isEmpty() || cur != null) {
if (cur != null) {
stack.push(cur);
cur = cur.left;
} else {
cur = stack.pop();
System.out.print(cur.val + " ");
cur = cur.right;
}
}
}
System.out.println();
}
private static void posOrderRecur(TreeNode head) {
if (head == null)
return;
if (head.left != null)
posOrderRecur(head.left);
if (head.right != null)
posOrderRecur(head.right);
System.out.print(head.val + " ");
}
public static void preOrderRecur(TreeNode head) {
// 递归先序遍历二叉树
if (head == null) {
return;
}
System.out.print(head.val + " ");
if (head.left != null) {
preOrderRecur(head.left);
}
if (head.right != null) {
preOrderRecur(head.right);
}
}
private static void preOrderUnRecur(TreeNode head) {
Stack<TreeNode> stack = new Stack<>();
// 1.將head入栈
stack.add(head);
while (!stack.isEmpty()) {
// 栈不为空 先打印栈顶结点的val 在进行出栈操作。
TreeNode temp = stack.peek();
System.out.print(temp.val + " ");
stack.pop();
if (temp.right != null) {
stack.push(temp.right);
}
if (temp.left != null) {
stack.push(temp.left);
}
}
System.out.println();
}
private static void inOrderRecur(TreeNode head) {
// 递归的中序遍历
if (head == null)
return;
if (head.left != null) {
inOrderRecur(head.left);
}
System.out.print(head.val + " ");
if (head.right != null) {
inOrderRecur(head.right);
}
}
}
| [
"1209011672@qq.com"
] | 1209011672@qq.com |
ec2e443c7b1fbf87e85cd3ed9d64a9302b3dc934 | a9efc7522734c6249f18aed30af150a9a0cc03cb | /src/main/java/ph/mobile/training/extra/TwoDArray.java | 33ac7e8297e84563d22d730ea8f35febf8beac85 | [] | no_license | winkzzz/javeTest | 3b059d84d5cfedbf403e4e07e81b7ba4a1ee2de8 | 186d0d1803762b301c5e66ead63ac527ca24707d | refs/heads/master | 2023-01-25T01:44:12.199604 | 2020-12-07T08:42:23 | 2020-12-07T08:42:23 | 285,503,867 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,297 | java | package ph.mobile.training.extra;
import java.util.Random;
public class TwoDArray {
public static void main(String[] args) {
int [][] twoD = {
{1,2,3,4,5,6,7,8,9,10},
{11,12,13,14,15,16,17,18,19,20},
{21,22,23,24,25,26,27,28,29,30},
{31,32,33,34,35,36,37,38,39,40},
{41,42,43,44,45,46,47,48,49,50},
{51,52,53,54,55,56,57,58,59,60},
{61,62,63,64,65,66,67,68,69,70},
{71,72,73,74,75,76,77,78,79,80},
{81,82,83,84,85,86,87,88,89,90},
{91,92,93,94,95,96,97,98,99,100},
};
int row;
int col;
for (row = 0; row < 10; row++){
for (col = 0; col < 10; col++){
System.out.print(" "+ twoD[row][col]+ " |");
}
System.out.println();
}
Random random = new Random();
int[] result = new int[10];
for(int i = 0; i < result.length; i++){
int num = random.nextInt(100);
result[i] = num;
}
System.out.print("Keno result: {"+result[0]+", "+result[1]+", "+result[2]+", "+result[3]+", "+result[4]+", "+result[5]+", "+result[6]+", "+result[7]+", "+result[8]+", "+result[9]+"}");
}
}
| [
"Winky.Dionisio@homecredit.ph"
] | Winky.Dionisio@homecredit.ph |
96c84ada001261f2345a7b129c15f3a3f7d0e361 | 557844058c3e7917512a4617694bd6ad907a22df | /app/src/test/java/com/sentrabilling/kasir/ExampleUnitTest.java | 632106860da641aabb7ece9eabc5b4cfcd2d6dda | [] | no_license | asrofie/TestFirebase | 6b86d3c8aa6e58394566ec617e38ce4861d07e38 | 20391481616bbbf440bea33a3bff76eac582b0ac | refs/heads/master | 2020-06-11T15:29:11.629981 | 2019-06-27T02:50:59 | 2019-06-27T02:50:59 | 194,011,483 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 384 | java | package com.sentrabilling.kasir;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() {
assertEquals(4, 2 + 2);
}
} | [
"asrofie.sentra@gmail.com"
] | asrofie.sentra@gmail.com |
a682d1bdfd6ba24206f02b0a748bdfac1ebc0819 | 2d15f1152782379a2d1cb57e3d0b1922aad999e1 | /app/src/main/java/com/example/ecommerceapp/util/dataBinding/FocusChange.java | 0b5f3d1648f22129a2b7dbbf6f0d51e3452fd389 | [] | no_license | abdsaidam95/EcommerceApp | da10a36ce65163e7e054e95562fd986a97a80d0e | fddc8252714077470e29b83f5d442b53a60b1939 | refs/heads/master | 2023-03-21T10:19:24.926211 | 2021-03-05T17:56:08 | 2021-03-05T17:56:08 | 342,668,575 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 127 | java | package com.example.ecommerceapp.util.dataBinding;
public interface FocusChange {
void onFocusChange(boolean hasFocus);
}
| [
"a.abod.2008@hotmail.com"
] | a.abod.2008@hotmail.com |
43a7d72469a6331035cf81e7e0079781a1ff935e | c1a8f552a8a203f4aa04d68ceda3c5a0f6b96269 | /core/src/com/ss/commons/BitmapFontC.java | 6c6f7b27d2280324836bf0589bbac35e948ac50b | [] | no_license | DanielDuong1998/ptgame-Animal | 146d5154a0cab34cdb910dd277b1529b658095c8 | 9c3172cb7edaa93761d31e522bf67046461ed44e | refs/heads/master | 2023-02-26T04:24:03.941106 | 2021-01-21T16:27:45 | 2021-01-21T16:27:45 | 306,805,007 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 835 | java | package com.ss.commons;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.ss.core.util.GAssetsManager;
public class BitmapFontC {
public static BitmapFont font_white;
public static BitmapFont font_brown;
public static BitmapFont FontAlert;
public static BitmapFont Font_brown_thin;
public static BitmapFont Font_Orange;
public static BitmapFont btnFont;
public static void initBitmapFont(){
font_white = GAssetsManager.getBitmapFont("fontWhite.fnt");
FontAlert = GAssetsManager.getBitmapFont("alert_font.fnt");
font_brown = GAssetsManager.getBitmapFont("font_brown.fnt");
Font_brown_thin = GAssetsManager.getBitmapFont("font_brown_thin.fnt");
Font_Orange = GAssetsManager.getBitmapFont("font_orange.fnt");
btnFont = GAssetsManager.getBitmapFont("font.fnt");
}
}
| [
"dvkhangnt@gmail.com"
] | dvkhangnt@gmail.com |
3be605c5861d4bc17fc3c3c4ee976b387d939c1c | 8eb72c70a896499455b2b19e2006cf21bd7e0154 | /app/src/main/java/fcb/de/fcbayernemotions/TopEmotionsActivity.java | aea90926419647e1f26ed53b42f131a6749ef394 | [] | no_license | b3nk4n/fcbayernhack.android | 1c37b2eaed09c7e3cc8af21d2b27fd41d31e0e4e | 19c9ec5fba772a2532698e14654b3df46867e459 | refs/heads/master | 2022-03-06T11:19:21.412367 | 2018-01-22T08:56:29 | 2018-01-22T08:56:29 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,331 | java | package fcb.de.fcbayernemotions;
import android.content.Intent;
import android.media.MediaPlayer;
import android.net.Uri;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.VideoView;
import java.util.ArrayList;
import java.util.List;
public class TopEmotionsActivity extends AppCompatActivity {
private VideoView videoView;
private int playingIndex = 0;
private List<Uri> videoUriList = new ArrayList<>();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_top_emotions);
setTitle("Top Fan Emotions");
videoView = findViewById(R.id.videoView);
videoUriList.add(Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.fan01));
videoUriList.add(Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.fan02));
videoUriList.add(Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.fan05));
videoView.setDrawingCacheEnabled(true);
videoView.setVideoURI(videoUriList.get(playingIndex));
videoView.requestFocus();
videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
@Override
public void onPrepared(MediaPlayer mp) {
mp.setVolume(0, 0);
}
});
videoView.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mediaPlayer) {
playingIndex++;
if (playingIndex == videoUriList.size()) {
// we are done, navigate to the reaction list.
Intent intent = new Intent(TopEmotionsActivity.this,
MainActivity.class);
startActivity(intent);
} else {
// show the next video
videoView.stopPlayback();
videoView.setDrawingCacheEnabled(true);
videoView.setVideoURI(videoUriList.get(playingIndex));
videoView.start();
}
}
});
}
@Override
protected void onResume() {
super.onResume();
videoView.start();
}
}
| [
"apps@bsautermeister.de"
] | apps@bsautermeister.de |
ad1c4ed0d0d95e202038a8fd3bf985c167e58706 | 53204595f0ce28dfaa939114a7901d7ada033c26 | /src/com/xclink/ch06/exam/Keyboard.java | 5095fdc3f37b2a04e0f2ee9fb9e1f9537cc6ab4b | [] | no_license | hongdk/beginner | 0cfe0809f51df0dc6015442fc5ef5ab953d591af | c134bd7570f1c4841314eea49570dce48feceb42 | refs/heads/master | 2020-03-20T03:27:50.461046 | 2018-06-13T03:18:26 | 2018-06-13T03:18:26 | 137,147,105 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 706 | java | package com.xclink.ch06.exam;
public class Keyboard extends InputDevice {
private int keyCount;
public Keyboard(int id) {
this.setId(id);
}
@Override
String getInputData() {
// TODO Auto-generated method stub
System.out.println("键盘输入中");
return "helloworld";
}
@Override
void startup() {
// TODO Auto-generated method stub
System.out.println("键盘开启"+this.getId());
}
@Override
void shutdown() {
// TODO Auto-generated method stub
System.out.println("键盘关闭"+this.getId());
}
public int getKeyCount() {
return keyCount;
}
public void setKeyCount(int keyCount) {
this.keyCount = keyCount;
}
}
| [
"hongdk@ontheway"
] | hongdk@ontheway |
cd676fb5fc649873e00d3d41a5ea69a8fe8e9264 | fe963d92ea2178e5d0bbf35adac1c008e569ef9b | /src/interfaces/Repair.java | 48a444d5de09bdb4ecf1b991926f2df318099516 | [] | no_license | brambooo/Java-understanding-the-basics | b62722c6051fb2c47f3e4de80899bf5f45a8b206 | a57ad80a446d9adbc7eb70f34ed6e531b873bab6 | refs/heads/master | 2021-01-19T01:24:14.821306 | 2016-07-18T16:03:53 | 2016-07-18T16:03:53 | 63,617,349 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 122 | java | package interfaces;
public interface Repair {
// Methods
public void needRepair();
public void repairDetails();
}
| [
"bram_reinold@hotmail.com"
] | bram_reinold@hotmail.com |
076057e9dfcc8821a684e50ffc608bbe5952d296 | 39c49b324d0ee9a86229c4f310da9ad7971e9831 | /src/main/java/level1/exercise/Array5.java | cf231e0b68b29a41b73fdec78137655446a94226 | [] | no_license | zhwei5311/study | e3f9abc3aba5eedaf1e8ed6ae7e9db949e7e7b74 | e7b4847684349d596f8d4c9b29d502c47607a13d | refs/heads/master | 2022-07-09T09:54:57.948953 | 2022-06-21T12:55:11 | 2022-06-21T12:55:11 | 231,111,954 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 458 | java | package com.study.exercise;
/**
* 定义一个数组来存储10个学生的成绩{72,89,65,87,91,82,71,93,76,68}，计算并输出学生的平均成绩。
*/
public class Array5 {
public static void main(String[] args) {
int[] arr = new int[]{72, 89, 65, 87, 91, 82, 71, 93, 76, 68};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.err.println(sum / arr.length);
}
}
| [
"zhwei1228@qq.com"
] | zhwei1228@qq.com |
1351f53d9748c51ae5ea80de9dcc0d794c5cfe3a | 9bb4cf7e03f137506067062a25167357d577e5bb | /wirez-core/wirez-commons/wirez-client-common/src/main/java/org/wirez/core/client/validation/canvas/CanvasValidatorImpl.java | cc7c3048a510daf994a85c2cfc601d65f1e21168 | [] | no_license | pefernan/wirez | 78840906c36e4629167b0254e11d88756b948302 | 537a95790b274e48e0a2d5da86956495f85376c8 | refs/heads/master | 2021-01-14T14:23:09.756622 | 2016-08-30T09:26:33 | 2016-08-30T09:26:33 | 56,070,487 | 0 | 0 | null | 2016-04-12T14:31:17 | 2016-04-12T14:31:15 | null | UTF-8 | Java | false | false | 4,439 | java | package org.wirez.core.client.validation.canvas;
import org.wirez.core.client.canvas.Canvas;
import org.wirez.core.client.canvas.CanvasHandler;
import org.wirez.core.client.shape.Shape;
import org.wirez.core.client.util.ShapeStateUtils;
import org.wirez.core.graph.Edge;
import org.wirez.core.graph.Element;
import org.wirez.core.graph.Graph;
import org.wirez.core.graph.Node;
import org.wirez.core.rule.graph.GraphRulesManager;
import org.wirez.core.validation.AbstractValidator;
import org.wirez.core.validation.graph.AbstractGraphValidatorCallback;
import org.wirez.core.validation.graph.GraphValidationViolation;
import org.wirez.core.validation.graph.GraphValidator;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import java.util.Collection;
import java.util.LinkedList;
@ApplicationScoped
public class CanvasValidatorImpl
extends AbstractValidator<CanvasHandler, CanvasValidatorCallback>
implements CanvasValidator {
GraphValidator graphValidator;
ShapeStateUtils shapeStateUtils;
private GraphRulesManager rulesManager = null;
@Inject
public CanvasValidatorImpl( final GraphValidator graphValidator,
final ShapeStateUtils shapeStateUtils ) {
this.graphValidator = graphValidator;
this.shapeStateUtils = shapeStateUtils;
}
@Override
public CanvasValidator withRulesManager( final GraphRulesManager rulesManager ) {
this.rulesManager = rulesManager;
return this;
}
@Override
@SuppressWarnings( "unchecked" )
public void validate( final CanvasHandler canvasHandler,
final CanvasValidatorCallback callback ) {
final Graph graph = canvasHandler.getDiagram().getGraph();
graphValidator
.withRulesManager( rulesManager )
.validate( graph, new AbstractGraphValidatorCallback() {
@Override
public void afterValidateNode( final Node node,
final Iterable<GraphValidationViolation> violations ) {
super.afterValidateNode( node, violations );
checkViolations( canvasHandler, node, violations );
}
@Override
public void afterValidateEdge( final Edge edge,
final Iterable<GraphValidationViolation> violations ) {
super.afterValidateEdge( edge, violations );
checkViolations( canvasHandler, edge, violations );
}
@Override
public void onSuccess() {
callback.onSuccess();
}
@Override
public void onFail( final Iterable<GraphValidationViolation> violations ) {
final Collection<CanvasValidationViolation> canvasValidationViolations = new LinkedList<CanvasValidationViolation>();
for ( final GraphValidationViolation violation : violations ) {
final CanvasValidationViolation canvasValidationViolation =
new CanvasValidationViolationImpl( canvasHandler, violation );
canvasValidationViolations.add( canvasValidationViolation );
}
callback.onFail( canvasValidationViolations );
}
} );
}
private void checkViolations( final CanvasHandler canvasHandler,
final Element element,
final Iterable<GraphValidationViolation> violations ) {
if ( hasViolations( violations ) ) {
final Canvas canvas = canvasHandler.getCanvas();
final Shape shape = getShape( canvasHandler, element.getUUID() );
shapeStateUtils.invalid( canvas, shape );
}
}
private Shape getShape( final CanvasHandler canvasHandler,
final String uuid ) {
return canvasHandler.getCanvas().getShape( uuid );
}
private boolean hasViolations( final Iterable<GraphValidationViolation> violations ) {
return violations != null && violations.iterator().hasNext();
}
}
| [
"roger600@gmail.com"
] | roger600@gmail.com |
8fa10c4bbfb6c16a6bbada9e18ce1bd3830ad514 | 2aa19af95239383d9df18b8b864421f7a2c81559 | /day12/String/ScannerLongTest.java | c77c42baaa71fd85a4fdbfc2c51c22cef4dd8926 | [] | no_license | Yasin27878/workspace | c18c79f675dfc8d95182a1379e3c1f00b2f3d9c6 | 2dd7686f4dd1df2491c6ae3f482a6aba40016883 | refs/heads/master | 2020-12-28T21:52:07.882036 | 2014-12-31T04:38:16 | 2014-12-31T04:38:16 | null | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 347 | java | import java.util.Scanner;
public class ScannerLongTest{
public static void main(String[] args){
//System.in 代表标准输入 就是键盘输入
Scanner sc = new Scanner(System.in);
//判断是否还有一个long整数
while(sc.hasNextLong()){
//输出输入项
System.out.println("键盘输入的内容是:"+ sc.nextLong());
}
}
} | [
"yili270@163.com"
] | yili270@163.com |
2e85d6d1bbd8bf74a7134e540691c3c9e19f5f4a | d599184d534461afda56a6b5dfbb6c0605f63c7e | /app/src/main/java/com/comet/androidstreaming/media/extractors/mp4/MetadataUtil.java | d969f50f7dfb9a692e6c185942bdac5ed68d0fe5 | [] | no_license | EverglowingComet/ExoPlayerSample | 6eb4d6a84b74164b84245d4a3d0c2ccdae97d5d4 | 00b12bbf66fcc666b5a6efa4c8761829db839c8f | refs/heads/master | 2020-07-29T05:04:43.679288 | 2019-09-20T01:40:05 | 2019-09-20T01:40:05 | 209,679,892 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 16,320 | java | package com.comet.androidstreaming.media.extractors.mp4;
import android.util.Log;
import com.google.android.exoplayer2.metadata.Metadata;
import com.google.android.exoplayer2.metadata.id3.ApicFrame;
import com.google.android.exoplayer2.metadata.id3.CommentFrame;
import com.google.android.exoplayer2.metadata.id3.Id3Frame;
import com.google.android.exoplayer2.metadata.id3.TextInformationFrame;
import com.google.android.exoplayer2.util.ParsableByteArray;
import com.google.android.exoplayer2.util.Util;
/**
* Parses metadata items stored in ilst atoms.
*/
/* package */ final class MetadataUtil {
private static final String TAG = "MetadataUtil";
// Codes that start with the copyright character (omitted) and have equivalent ID3 frames.
private static final int SHORT_TYPE_NAME_1 = Util.getIntegerCodeForString("nam");
private static final int SHORT_TYPE_NAME_2 = Util.getIntegerCodeForString("trk");
private static final int SHORT_TYPE_COMMENT = Util.getIntegerCodeForString("cmt");
private static final int SHORT_TYPE_YEAR = Util.getIntegerCodeForString("day");
private static final int SHORT_TYPE_ARTIST = Util.getIntegerCodeForString("ART");
private static final int SHORT_TYPE_ENCODER = Util.getIntegerCodeForString("too");
private static final int SHORT_TYPE_ALBUM = Util.getIntegerCodeForString("alb");
private static final int SHORT_TYPE_COMPOSER_1 = Util.getIntegerCodeForString("com");
private static final int SHORT_TYPE_COMPOSER_2 = Util.getIntegerCodeForString("wrt");
private static final int SHORT_TYPE_LYRICS = Util.getIntegerCodeForString("lyr");
private static final int SHORT_TYPE_GENRE = Util.getIntegerCodeForString("gen");
// Codes that have equivalent ID3 frames.
private static final int TYPE_COVER_ART = Util.getIntegerCodeForString("covr");
private static final int TYPE_GENRE = Util.getIntegerCodeForString("gnre");
private static final int TYPE_GROUPING = Util.getIntegerCodeForString("grp");
private static final int TYPE_DISK_NUMBER = Util.getIntegerCodeForString("disk");
private static final int TYPE_TRACK_NUMBER = Util.getIntegerCodeForString("trkn");
private static final int TYPE_TEMPO = Util.getIntegerCodeForString("tmpo");
private static final int TYPE_COMPILATION = Util.getIntegerCodeForString("cpil");
private static final int TYPE_ALBUM_ARTIST = Util.getIntegerCodeForString("aART");
private static final int TYPE_SORT_TRACK_NAME = Util.getIntegerCodeForString("sonm");
private static final int TYPE_SORT_ALBUM = Util.getIntegerCodeForString("soal");
private static final int TYPE_SORT_ARTIST = Util.getIntegerCodeForString("soar");
private static final int TYPE_SORT_ALBUM_ARTIST = Util.getIntegerCodeForString("soaa");
private static final int TYPE_SORT_COMPOSER = Util.getIntegerCodeForString("soco");
// Types that do not have equivalent ID3 frames.
private static final int TYPE_RATING = Util.getIntegerCodeForString("rtng");
private static final int TYPE_GAPLESS_ALBUM = Util.getIntegerCodeForString("pgap");
private static final int TYPE_TV_SORT_SHOW = Util.getIntegerCodeForString("sosn");
private static final int TYPE_TV_SHOW = Util.getIntegerCodeForString("tvsh");
// Type for items that are intended for internal use by the player.
private static final int TYPE_INTERNAL = Util.getIntegerCodeForString("----");
// Standard genres.
private static final String[] STANDARD_GENRES = new String[] {
// These are the official ID3v1 genres.
"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz",
"Metal", "New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno",
"Industrial", "Alternative", "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno",
"Ambient", "Trip-Hop", "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
"Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock", "Bass", "Soul",
"Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic",
"Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream",
"Southern Rock", "Comedy", "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
"Native American", "Cabaret", "New Wave", "Psychadelic", "Rave", "Showtunes", "Trailer",
"Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll",
"Hard Rock",
// These were made up by the authors of Winamp and later added to the ID3 spec.
"Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob", "Latin", "Revival",
"Celtic", "Bluegrass", "Avantgarde", "Gothic Rock", "Progressive Rock", "Psychedelic Rock",
"Symphonic Rock", "Slow Rock", "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour",
"Speech", "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", "Primus",
"Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba", "Folklore", "Ballad",
"Power Ballad", "Rhythmic Soul", "Freestyle", "Duet", "Punk Rock", "Drum Solo", "A capella",
"Euro-House", "Dance Hall",
// These were med up by the authors of Winamp but have not been added to the ID3 spec.
"Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie", "BritPop", "Negerpunk",
"Polsk Punk", "Beat", "Christian Gangsta Rap", "Heavy Metal", "Black Metal", "Crossover",
"Contemporary Christian", "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime",
"Jpop", "Synthpop"
};
private static final String LANGUAGE_UNDEFINED = "und";
private MetadataUtil() {}
/**
* Parses a single ilst element from a {@link ParsableByteArray}. The element is read starting
* from the current position of the {@link ParsableByteArray}, and the position is advanced by
* the size of the element. The position is advanced even if the element's type is unrecognized.
*
* @param ilst Holds the data to be parsed.
* @return The parsed element, or null if the element's type was not recognized.
*/
public static Metadata.Entry parseIlstElement(ParsableByteArray ilst) {
int position = ilst.getPosition();
int endPosition = position + ilst.readInt();
int type = ilst.readInt();
int typeTopByte = (type >> 24) & 0xFF;
try {
if (typeTopByte == '\u00A9' /* Copyright char */
|| typeTopByte == '\uFFFD' /* Replacement char */) {
int shortType = type & 0x00FFFFFF;
if (shortType == SHORT_TYPE_COMMENT) {
return parseCommentAttribute(type, ilst);
} else if (shortType == SHORT_TYPE_NAME_1 || shortType == SHORT_TYPE_NAME_2) {
return parseTextAttribute(type, "TIT2", ilst);
} else if (shortType == SHORT_TYPE_COMPOSER_1 || shortType == SHORT_TYPE_COMPOSER_2) {
return parseTextAttribute(type, "TCOM", ilst);
} else if (shortType == SHORT_TYPE_YEAR) {
return parseTextAttribute(type, "TDRC", ilst);
} else if (shortType == SHORT_TYPE_ARTIST) {
return parseTextAttribute(type, "TPE1", ilst);
} else if (shortType == SHORT_TYPE_ENCODER) {
return parseTextAttribute(type, "TSSE", ilst);
} else if (shortType == SHORT_TYPE_ALBUM) {
return parseTextAttribute(type, "TALB", ilst);
} else if (shortType == SHORT_TYPE_LYRICS) {
return parseTextAttribute(type, "USLT", ilst);
} else if (shortType == SHORT_TYPE_GENRE) {
return parseTextAttribute(type, "TCON", ilst);
} else if (shortType == TYPE_GROUPING) {
return parseTextAttribute(type, "TIT1", ilst);
}
} else if (type == TYPE_GENRE) {
return parseStandardGenreAttribute(ilst);
} else if (type == TYPE_DISK_NUMBER) {
return parseIndexAndCountAttribute(type, "TPOS", ilst);
} else if (type == TYPE_TRACK_NUMBER) {
return parseIndexAndCountAttribute(type, "TRCK", ilst);
} else if (type == TYPE_TEMPO) {
return parseUint8Attribute(type, "TBPM", ilst, true, false);
} else if (type == TYPE_COMPILATION) {
return parseUint8Attribute(type, "TCMP", ilst, true, true);
} else if (type == TYPE_COVER_ART) {
return parseCoverArt(ilst);
} else if (type == TYPE_ALBUM_ARTIST) {
return parseTextAttribute(type, "TPE2", ilst);
} else if (type == TYPE_SORT_TRACK_NAME) {
return parseTextAttribute(type, "TSOT", ilst);
} else if (type == TYPE_SORT_ALBUM) {
return parseTextAttribute(type, "TSO2", ilst);
} else if (type == TYPE_SORT_ARTIST) {
return parseTextAttribute(type, "TSOA", ilst);
} else if (type == TYPE_SORT_ALBUM_ARTIST) {
return parseTextAttribute(type, "TSOP", ilst);
} else if (type == TYPE_SORT_COMPOSER) {
return parseTextAttribute(type, "TSOC", ilst);
} else if (type == TYPE_RATING) {
return parseUint8Attribute(type, "ITUNESADVISORY", ilst, false, false);
} else if (type == TYPE_GAPLESS_ALBUM) {
return parseUint8Attribute(type, "ITUNESGAPLESS", ilst, false, true);
} else if (type == TYPE_TV_SORT_SHOW) {
return parseTextAttribute(type, "TVSHOWSORT", ilst);
} else if (type == TYPE_TV_SHOW) {
return parseTextAttribute(type, "TVSHOW", ilst);
} else if (type == TYPE_INTERNAL) {
return parseInternalAttribute(ilst, endPosition);
}
Log.d(TAG, "Skipped unknown metadata entry: " + Atom.getAtomTypeString(type));
return null;
} finally {
ilst.setPosition(endPosition);
}
}
private static TextInformationFrame parseTextAttribute(int type, String id,
ParsableByteArray data) {
int atomSize = data.readInt();
int atomType = data.readInt();
if (atomType == Atom.TYPE_data) {
data.skipBytes(8); // version (1), flags (3), empty (4)
String value = data.readNullTerminatedString(atomSize - 16);
return new TextInformationFrame(id, null, value);
}
Log.w(TAG, "Failed to parse text attribute: " + Atom.getAtomTypeString(type));
return null;
}
private static CommentFrame parseCommentAttribute(int type, ParsableByteArray data) {
int atomSize = data.readInt();
int atomType = data.readInt();
if (atomType == Atom.TYPE_data) {
data.skipBytes(8); // version (1), flags (3), empty (4)
String value = data.readNullTerminatedString(atomSize - 16);
return new CommentFrame(LANGUAGE_UNDEFINED, value, value);
}
Log.w(TAG, "Failed to parse comment attribute: " + Atom.getAtomTypeString(type));
return null;
}
private static Id3Frame parseUint8Attribute(int type, String id, ParsableByteArray data,
boolean isTextInformationFrame, boolean isBoolean) {
int value = parseUint8AttributeValue(data);
if (isBoolean) {
value = Math.min(1, value);
}
if (value >= 0) {
return isTextInformationFrame ? new TextInformationFrame(id, null, Integer.toString(value))
: new CommentFrame(LANGUAGE_UNDEFINED, id, Integer.toString(value));
}
Log.w(TAG, "Failed to parse uint8 attribute: " + Atom.getAtomTypeString(type));
return null;
}
private static TextInformationFrame parseIndexAndCountAttribute(int type, String attributeName,
ParsableByteArray data) {
int atomSize = data.readInt();
int atomType = data.readInt();
if (atomType == Atom.TYPE_data && atomSize >= 22) {
data.skipBytes(10); // version (1), flags (3), empty (4), empty (2)
int index = data.readUnsignedShort();
if (index > 0) {
String value = "" + index;
int count = data.readUnsignedShort();
if (count > 0) {
value += "/" + count;
}
return new TextInformationFrame(attributeName, null, value);
}
}
Log.w(TAG, "Failed to parse index/count attribute: " + Atom.getAtomTypeString(type));
return null;
}
private static TextInformationFrame parseStandardGenreAttribute(ParsableByteArray data) {
int genreCode = parseUint8AttributeValue(data);
String genreString = (0 < genreCode && genreCode <= STANDARD_GENRES.length)
? STANDARD_GENRES[genreCode - 1] : null;
if (genreString != null) {
return new TextInformationFrame("TCON", null, genreString);
}
Log.w(TAG, "Failed to parse standard genre code");
return null;
}
private static ApicFrame parseCoverArt(ParsableByteArray data) {
int atomSize = data.readInt();
int atomType = data.readInt();
if (atomType == Atom.TYPE_data) {
int fullVersionInt = data.readInt();
int flags = Atom.parseFullAtomFlags(fullVersionInt);
String mimeType = flags == 13 ? "image/jpeg" : flags == 14 ? "image/png" : null;
if (mimeType == null) {
Log.w(TAG, "Unrecognized cover art flags: " + flags);
return null;
}
data.skipBytes(4); // empty (4)
byte[] pictureData = new byte[atomSize - 16];
data.readBytes(pictureData, 0, pictureData.length);
return new ApicFrame(mimeType, null, 3 /* Cover (front) */, pictureData);
}
Log.w(TAG, "Failed to parse cover art attribute");
return null;
}
private static Id3Frame parseInternalAttribute(ParsableByteArray data, int endPosition) {
String domain = null;
String name = null;
int dataAtomPosition = -1;
int dataAtomSize = -1;
while (data.getPosition() < endPosition) {
int atomPosition = data.getPosition();
int atomSize = data.readInt();
int atomType = data.readInt();
data.skipBytes(4); // version (1), flags (3)
if (atomType == Atom.TYPE_mean) {
domain = data.readNullTerminatedString(atomSize - 12);
} else if (atomType == Atom.TYPE_name) {
name = data.readNullTerminatedString(atomSize - 12);
} else {
if (atomType == Atom.TYPE_data) {
dataAtomPosition = atomPosition;
dataAtomSize = atomSize;
}
data.skipBytes(atomSize - 12);
}
}
if (!"com.apple.iTunes".equals(domain) || !"iTunSMPB".equals(name) || dataAtomPosition == -1) {
// We're only interested in iTunSMPB.
return null;
}
data.setPosition(dataAtomPosition);
data.skipBytes(16); // size (4), type (4), version (1), flags (3), empty (4)
String value = data.readNullTerminatedString(dataAtomSize - 16);
return new CommentFrame(LANGUAGE_UNDEFINED, name, value);
}
private static int parseUint8AttributeValue(ParsableByteArray data) {
data.skipBytes(4); // atomSize
int atomType = data.readInt();
if (atomType == Atom.TYPE_data) {
data.skipBytes(8); // version (1), flags (3), empty (4)
return data.readUnsignedByte();
}
Log.w(TAG, "Failed to parse uint8 attribute value");
return -1;
}
}
| [
"everglowingComet@hotmail.com"
] | everglowingComet@hotmail.com |
751fbf9c6484a773b6adfdc3ff8f0ec91d2ce958 | 319a371ab83c04a9a2466b0ec1e2a67b93fa7f2f | /zj-lzeh/src/main/java/com/apih5/mybatis/dao/ZjLzehProduceTaskPlanItemMapper.java | 305175709aaaf987ae869ad2a2c359445045979e | [] | no_license | zhangrenyi666/apih5-2 | 0232faa65e2968551d55db47fb35f689e5a03996 | afd9b7d574fab11410aab5e0465a0bd706bcf942 | refs/heads/master | 2023-08-01T13:11:51.678508 | 2021-09-10T05:52:34 | 2021-09-10T05:52:34 | 406,647,352 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,031 | java | package com.apih5.mybatis.dao;
import java.util.List;
import com.apih5.mybatis.pojo.ZjLzehProduceTaskPlanItem;
import org.apache.ibatis.annotations.Param;
public interface ZjLzehProduceTaskPlanItemMapper {
int deleteByPrimaryKey(String key);
int insert(ZjLzehProduceTaskPlanItem record);
int insertSelective(ZjLzehProduceTaskPlanItem record);
ZjLzehProduceTaskPlanItem selectByPrimaryKey(String key);
int updateByPrimaryKeySelective(ZjLzehProduceTaskPlanItem record);
int updateByPrimaryKey(ZjLzehProduceTaskPlanItem record);
List<ZjLzehProduceTaskPlanItem> selectByZjLzehProduceTaskPlanItemList(ZjLzehProduceTaskPlanItem record);
int batchDeleteUpdateZjLzehProduceTaskPlanItem(List<ZjLzehProduceTaskPlanItem> recordList, ZjLzehProduceTaskPlanItem record);
// ↓↓↓----扩展-（命名格式：select查询；update更新；sum统计；count数量）----↓↓↓
int insertProduceTaskPlanItemList(@Param("excelImportList") List<ZjLzehProduceTaskPlanItem> excelImportList);
}
| [
"2267843676@qq.com"
] | 2267843676@qq.com |
da9641e7ba55c31ec20e7888ef3b35c3aed51f8d | 89c78dd261fc9f0324242d77f9afaf5d5a3299e7 | /winaxmusicplayer/Music Player/app/src/main/java/com/winax/musicplayer/timely/model/number/Four.java | 4ccf75c477662a48dd108235027de78f3e146c2d | [] | no_license | KesarkarMadhuri30/projects | 67f9e2253fa1dd6d87c5ada85e5392ec172aea46 | 87e9a95d2beed4df5106f3cb365a8702680cade6 | refs/heads/master | 2020-03-06T17:02:02.713401 | 2018-03-27T13:21:48 | 2018-03-27T13:21:48 | 126,983,114 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 975 | java | package com.winax.musicplayer.timely.model.number;
import com.winax.musicplayer.timely.model.core.Figure;
public class Four extends Figure {
private static final float[][] POINTS = {
{0.856353591160221f, 0.806629834254144f}, {0.856353591160221f, 0.806629834254144f}, {0.237569060773481f, 0.806629834254144f},
{0.237569060773481f, 0.806629834254144f}, {0.237569060773481f, 0.806629834254144f}, {0.712707182320442f, 0.138121546961326f},
{0.712707182320442f, 0.138121546961326f}, {0.712707182320442f, 0.138121546961326f}, {0.712707182320442f, 0.806629834254144f},
{0.712707182320442f, 0.806629834254144f}, {0.712707182320442f, 0.806629834254144f}, {0.712707182320442f, 0.988950276243094f},
{0.712707182320442f, 0.988950276243094f}
};
private static Four INSTANCE = new Four();
protected Four() {
super(POINTS);
}
public static Four getInstance() {
return INSTANCE;
}
} | [
"35532561+KesarkarMadhuri30@users.noreply.github.com"
] | 35532561+KesarkarMadhuri30@users.noreply.github.com |
17e042800f0da271b29770df0a7a0798038eb417 | b885c9e21445e1738559b7f56577c41202e578d7 | /src/py/una/maverick/domain/Mano.java | 6bb73dfd82c5af12d45299c367ca7557b7851975 | [] | no_license | JCorrales/maverick | 035deb13311f4e5051bbdcecbc7abe6c7647dbbf | 6ffe4bd0a8da18140b3c9d5b4dc44cb137376ec1 | refs/heads/master | 2021-01-13T09:19:10.666694 | 2016-10-29T17:25:02 | 2016-10-29T17:25:02 | 69,929,452 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,882 | java | package py.una.maverick.domain;
import java.util.Collections;
import java.util.List;
/**
*
* @author Juan Andrés Corrales Duarte
*/
public class Mano {
private Integer valor;
private List<Carta> mano;
private List<Carta> kickers;
public Mano(Integer valor, List<Carta> mano, List<Carta> kickers) {
this.valor = valor;
this.mano = mano;
this.kickers = kickers;
}
public List<Carta> getKickers() {
return kickers;
}
public void setKickers(List<Carta> kickers) {
this.kickers = kickers;
}
public Integer getValor() {
return valor;
}
public void setValor(Integer valor) {
this.valor = valor;
}
public List<Carta> getMano() {
return mano;
}
public void setMano(List<Carta> mano) {
this.mano = mano;
}
public int compareTo(Mano otra){
System.out.println("this: "+ C.RANK_NAMES[this.valor]);
System.out.println("other: "+ C.RANK_NAMES[otra.getValor().intValue()]);
if(this.valor > otra.getValor().intValue()){
return 1;
}
if(this.valor < otra.getValor().intValue()){
return -1;
}
if(valor == C.PAR){
if(mano.get(0).getNumero() > otra.getMano().get(0).getNumero()){
return 1;
}else if(mano.get(0).getNumero() < otra.getMano().get(0).getNumero()){
return -1;
}
}
if(valor == C.DOS_PARES){
if(mano.get(0).getNumero() > otra.getMano().get(0).getNumero()){
return 1;
}else if(mano.get(0).getNumero() < otra.getMano().get(0).getNumero()){
return -1;
}
if(mano.get(2).getNumero() > otra.getMano().get(2).getNumero()){
return 1;
}else if(mano.get(2).getNumero() < otra.getMano().get(2).getNumero()){
return -1;
}
}
if(valor == C.TRIO){
if(mano.get(0).getNumero() > otra.getMano().get(0).getNumero()){
return 1;
}else if(mano.get(0).getNumero() < otra.getMano().get(0).getNumero()){
return -1;
}
}
if(valor == C.ESCALERA){
if(mano.get(4).getNumero() > otra.getMano().get(4).getNumero()){
return 1;
}else if(mano.get(4).getNumero() < otra.getMano().get(4).getNumero()){
return -1;
}
}
if(valor == C.FULL){
if(mano.get(0).getNumero() > otra.getMano().get(0).getNumero()){
return 1;
}else if(mano.get(0).getNumero() < otra.getMano().get(0).getNumero()){
return -1;
}
if(mano.get(3).getNumero() > otra.getMano().get(3).getNumero()){
return 1;
}else if(mano.get(3).getNumero() < otra.getMano().get(3).getNumero()){
return -1;
}
}
if(valor == C.POKER){
if(mano.get(0).getNumero() > otra.getMano().get(0).getNumero()){
return 1;
}else if(mano.get(0).getNumero() < otra.getMano().get(0).getNumero()){
return -1;
}
}
//si this tiene kicker asumo que la otra mano tambien
if(kickers == null || kickers.isEmpty()){
return 0;
}
Collections.sort(kickers);
Collections.sort(otra.getKickers());
int i = 0;
for(Carta carta : kickers){
if(carta.getNumero() > otra.getKickers().get(i).getNumero()){
return 1;
}else if(carta.getNumero() < otra.getKickers().get(i).getNumero()){
return -1;
}
i++;
}
return 0;
}
}
| [
"juanandrescorrales@gmail.com"
] | juanandrescorrales@gmail.com |
c461d474eb60403b46866a2bb1f70a41c656d3c0 | aaac30301a5b18e8b930d9932a5e11d514924c7e | /framework/seckilldemo/src/main/java/me/maiz/project/highconcurrency/service/impl/ProductServiceImpl.java | c248313f972db86e6d5159af6a74dd5631f8e849 | [] | no_license | stickgoal/trainning | 9206e30fc0b17c817c5826a6e212ad25a3b9d8a6 | 58348f8a3d21e91cad54d0084078129e788ea1f4 | refs/heads/master | 2023-03-14T12:29:11.508957 | 2022-12-01T09:17:50 | 2022-12-01T09:17:50 | 91,793,279 | 1 | 0 | null | 2023-02-22T06:55:38 | 2017-05-19T10:06:01 | JavaScript | UTF-8 | Java | false | false | 814 | java | package me.maiz.project.highconcurrency.service.impl;
import me.maiz.project.highconcurrency.model.Product;
import me.maiz.project.highconcurrency.dao.ProductMapper;
import me.maiz.project.highconcurrency.service.IProductService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 商品 服务实现类
* </p>
*
* @author lucas
* @since 2020-03-03
*/
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements IProductService {
@Autowired
private ProductMapper productMapper;
@Override
public List<Product> query(int seckillId) {
return productMapper.query(seckillId);
}
}
| [
"stick.goal@163.com"
] | stick.goal@163.com |
27cd32ea2d2f845b070859aedf85631b61008abd | 865e5a7170b849fe4fa236262be8ff898f6a9759 | /src/com/gamebox_x/hostedit/models/HostEntity.java | f828f29ae4da11ecfc0ea43b668deb2125e8d202 | [] | no_license | mkikets99/hostsedit | 98b7d7dc2e3d60387912c20de5d81a51b72183f6 | e1979ffd083c340fa4c6d39aea672447583ffb69 | refs/heads/master | 2020-12-15T14:47:43.479868 | 2020-01-22T15:37:06 | 2020-01-22T15:37:06 | 235,143,412 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,017 | java | package com.gamebox_x.hostedit.models;
public class HostEntity {
private String ipaddress;
private String webaddress;
private Boolean disabled;
public HostEntity() {
this.ipaddress = "127.0.0.1";
this.webaddress = "localhost";
this.disabled = false;
}
public HostEntity(String ipaddress, String webaddress, Boolean disabled) {
super();
this.ipaddress = ipaddress;
this.webaddress = webaddress;
this.disabled = disabled;
}
public String getIpaddress() {
return ipaddress;
}
public Boolean getDisabled() {
return disabled;
}
public String getWebaddress() {
return webaddress;
}
public void setDisabled(Boolean disabled) {
this.disabled = disabled;
}
public void setIpaddress(String ipaddress) {
this.ipaddress = ipaddress;
}
public void setWebaddress(String webaddress) {
this.webaddress = webaddress;
}
@Override
public String toString() {
return ((disabled)? "#\t": " \t" ) + ipaddress + "\t" + webaddress;
}
}
| [
"mykola.kikets@gmail.com"
] | mykola.kikets@gmail.com |
7a294328a2f7aeec5731db4a1a8fc1ac9d0fa29e | 366c6c812e893ff90b2cd403f84cb3eac32cd1df | /src/ru/job4j/ru/job4j/Greeting.java | 51861af813bdf35e2c11cee7130514fd1abc188c | [] | no_license | DmitriyKimR/job4j_elementary | 2862273247825d15a0bc8481df3b4be825d1ea5b | cef943ceabd7379c43394684e6c738ea759d6153 | refs/heads/master | 2023-09-05T16:22:39.881621 | 2021-11-02T10:56:09 | 2021-11-02T10:56:09 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 339 | java | package ru.job4j.ru.job4j;
public class Greeting {
public static void main(String[] args) {
String idea = "I like Java! ";
System.out.println(idea);
idea += "But I am newbie ";
System.out.println(idea);
int year = 2021;
idea += year + " year";
System.out.println(idea);
}
}
| [
"incoming@mail.ru"
] | incoming@mail.ru |
4a697ddb2ee19ccecfbbee4b260b885b14a0af6d | 0732369f9a9c11ad06baa22c8d712d0a44a50291 | /app/src/main/java/com/example/administrator/coolweather/db/City.java | eea40c53dabe4a86171236a6ff58974778989cfb | [] | no_license | qianfangsnow/CoolWeather2 | cf380b9661da0aa6fc3c1743c3ad5a845c564f32 | 627994226a3dd26508e705e12630200029845291 | refs/heads/master | 2020-12-03T07:56:44.861610 | 2017-07-03T13:38:49 | 2017-07-03T13:38:49 | 95,641,310 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 833 | java | package com.example.administrator.coolweather.db;
import org.litepal.crud.DataSupport;
/**
* Created by Administrator on 2017/6/29.
*/
public class City extends DataSupport {
private int id;
private String cityName;
private int cityCode;
private int provinceId;
public int getId(){
return id;
}
public void setId(int id){
this.id=id;
}
public String getcityName(){
return cityName;
}
public void setcityName(String cityName){
this.cityName=cityName;
}
public int getcityCode(){
return cityCode;
}
public void setcityCode(int cityCode){
this.cityCode=cityCode;
}
public int getprinceId(){
return provinceId;
}
public void setProvinceId(int provinceId){
this.provinceId=provinceId;
}
}
| [
"674306244@qq.com"
] | 674306244@qq.com |
f78c695b26387ee5674b31e7c89ee5ac0e2dd9f2 | 0a6e41da01e43562e8a5ef6d227e10159fc253b3 | /server/acceptpayment/src/main/java/com/spring/exception/BestPayException.java | 42b3c287c9340f901fdd73ba3c5208552191883e | [] | no_license | chq347796066/base-interface | 917914190be0b487929f38d2cce68f7e396c149e | 356aabbdcf827c9a65083d17c3e7ade259801bfd | refs/heads/main | 2023-02-26T13:53:26.205433 | 2021-02-08T10:24:36 | 2021-02-08T10:24:36 | 337,037,239 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 412 | java | package com.spring.exception;
import com.spring.enums.BestPayResultEnum;
/**
*
* @author null
* @date 2017/2/23
*/
public class BestPayException extends RuntimeException {
private final Integer code;
public BestPayException(BestPayResultEnum resultEnum) {
super(resultEnum.getMsg());
code = resultEnum.getCode();
}
public Integer getCode() {
return code;
}
}
| [
"chq347796066@126.com"
] | chq347796066@126.com |
e8959be16ff67599e0b36f832559846a89d3f150 | 5b03a15b643cc741fa5b8dccf1a661338a400601 | /MPChartLib/src/com/github/mikephil/charting/renderer/HorizontalBarChartRenderer.java | 07c4492e3cb9abc6388ea27642b29fa7e84b4fb7 | [
"Apache-2.0"
] | permissive | LeonXtp/MPAndroidChart | f401edb81939dd22cf65169385d4f155fe3f8288 | 0b153157de387f26d1e49b0a167b0e565faa413e | refs/heads/master | 2021-05-28T04:00:11.663233 | 2015-03-13T21:12:51 | 2015-03-13T21:12:51 | 32,204,547 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 9,212 | java |
package com.github.mikephil.charting.renderer;
import android.graphics.Canvas;
import android.graphics.Paint.Align;
import com.github.mikephil.charting.animation.ChartAnimator;
import com.github.mikephil.charting.buffer.BarBuffer;
import com.github.mikephil.charting.buffer.HorizontalBarBuffer;
import com.github.mikephil.charting.data.BarData;
import com.github.mikephil.charting.data.BarDataSet;
import com.github.mikephil.charting.data.BarEntry;
import com.github.mikephil.charting.interfaces.BarDataProvider;
import com.github.mikephil.charting.utils.Transformer;
import com.github.mikephil.charting.utils.Utils;
import com.github.mikephil.charting.utils.ValueFormatter;
import java.util.ArrayList;
/**
* Renderer for the HorizontalBarChart.
*
* @author Philipp Jahoda
*/
public class HorizontalBarChartRenderer extends BarChartRenderer {
private float mYOffset = 0f;
public HorizontalBarChartRenderer(BarDataProvider chart, ChartAnimator animator,
ViewPortHandler viewPortHandler) {
super(chart, animator, viewPortHandler);
mValuePaint.setTextAlign(Align.LEFT);
}
@Override
public void initBuffers() {
BarData barData = mChart.getBarData();
mBarBuffers = new HorizontalBarBuffer[barData.getDataSetCount()];
for (int i = 0; i < mBarBuffers.length; i++) {
BarDataSet set = barData.getDataSetByIndex(i);
mBarBuffers[i] = new HorizontalBarBuffer(set.getValueCount() * 4 * set.getStackSize(),
barData.getGroupSpace(),
barData.getDataSetCount(), set.isStacked());
}
}
protected void drawDataSet(Canvas c, BarDataSet dataSet, int index) {
Transformer trans = mChart.getTransformer(dataSet.getAxisDependency());
calcXBounds(trans);
mShadowPaint.setColor(dataSet.getBarShadowColor());
float phaseX = mAnimator.getPhaseX();
float phaseY = mAnimator.getPhaseY();
ArrayList<BarEntry> entries = dataSet.getYVals();
// initialize the buffer
BarBuffer buffer = mBarBuffers[index];
buffer.setPhases(phaseX, phaseY);
buffer.setBarSpace(dataSet.getBarSpace());
buffer.setDataSet(index);
buffer.feed(entries);
trans.pointValuesToPixel(buffer.buffer);
for (int j = 0; j < buffer.size(); j += 4) {
if (!mViewPortHandler.isInBoundsTop(buffer.buffer[j + 3]))
break;
if (!mViewPortHandler.isInBoundsBottom(buffer.buffer[j + 1]))
continue;
if (mChart.isDrawBarShadowEnabled()) {
c.drawRect(mViewPortHandler.contentLeft(), buffer.buffer[j + 1],
mViewPortHandler.contentRight(),
buffer.buffer[j + 3], mShadowPaint);
}
// Set the color for the currently drawn value. If the index
// is
// out of bounds, reuse colors.
mRenderPaint.setColor(dataSet.getColor(j / 4));
c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
buffer.buffer[j + 3], mRenderPaint);
}
}
@Override
public void drawValues(Canvas c) {
// if values are drawn
if (passesCheck()) {
ArrayList<BarDataSet> dataSets = mChart.getBarData().getDataSets();
float posOffset = 0f;
float negOffset = 0f;
boolean drawValueAboveBar = mChart.isDrawValueAboveBarEnabled();
// calculate the correct offset depending on the draw position of
// the value
negOffset = drawValueAboveBar ? -Utils.convertDpToPixel(5) : Utils.convertDpToPixel(5);
posOffset = drawValueAboveBar ? Utils.convertDpToPixel(5) : -Utils.convertDpToPixel(5);
if (drawValueAboveBar)
mValuePaint.setTextAlign(Align.LEFT);
else
mValuePaint.setTextAlign(Align.RIGHT);
for (int i = 0; i < mChart.getBarData().getDataSetCount(); i++) {
BarDataSet dataSet = dataSets.get(i);
if (!dataSet.isDrawValuesEnabled())
continue;
// apply the text-styling defined by the DataSet
applyValueTextStyle(dataSet);
mYOffset = Utils.calcTextHeight(mValuePaint, "10") / 2f;
ValueFormatter formatter = dataSet.getValueFormatter();
Transformer trans = mChart.getTransformer(dataSet.getAxisDependency());
ArrayList<BarEntry> entries = dataSet.getYVals();
float[] valuePoints = getTransformedValues(trans, entries, i);
// if only single values are drawn (sum)
if (!mChart.isDrawValuesForWholeStackEnabled()) {
for (int j = 0; j < valuePoints.length * mAnimator.getPhaseX(); j += 2) {
if (!mViewPortHandler.isInBoundsX(valuePoints[j]))
continue;
if (!mViewPortHandler.isInBoundsTop(valuePoints[j + 1]))
break;
if (!mViewPortHandler.isInBoundsBottom(valuePoints[j + 1]))
continue;
float val = entries.get(j / 2).getVal();
drawValue(c, val, valuePoints[j] + (val >= 0 ? posOffset : negOffset),
valuePoints[j + 1], formatter);
}
// if each value of a potential stack should be drawn
} else {
for (int j = 0; j < (valuePoints.length - 1) * mAnimator.getPhaseX(); j += 2) {
BarEntry e = entries.get(j / 2);
float[] vals = e.getVals();
// we still draw stacked bars, but there is one
// non-stacked
// in between
if (vals == null) {
if (!mViewPortHandler.isInBoundsX(valuePoints[j]))
continue;
if (!mViewPortHandler.isInBoundsTop(valuePoints[j + 1]))
break;
if (!mViewPortHandler.isInBoundsBottom(valuePoints[j + 1]))
continue;
drawValue(c, e.getVal(), valuePoints[j]
+ (e.getVal() >= 0 ? posOffset : negOffset),
valuePoints[j + 1],
formatter);
} else {
float[] transformed = new float[vals.length * 2];
int cnt = 0;
float add = e.getVal();
for (int k = 0; k < transformed.length; k += 2) {
add -= vals[cnt];
transformed[k] = (vals[cnt] + add) * mAnimator.getPhaseY();
cnt++;
}
trans.pointValuesToPixel(transformed);
for (int k = 0; k < transformed.length; k += 2) {
float x = transformed[k]
+ (vals[k / 2] >= 0 ? posOffset : negOffset);
float y = valuePoints[j + 1];
if (!mViewPortHandler.isInBoundsX(x))
continue;
if (!mViewPortHandler.isInBoundsTop(y))
break;
if (!mViewPortHandler.isInBoundsBottom(y))
continue;
drawValue(c, vals[k / 2], x, y, formatter);
}
}
}
}
}
}
}
@Override
protected void prepareBarHighlight(float x, float y, float barspace, float from,
Transformer trans) {
float spaceHalf = barspace / 2f;
float top = x - 0.5f + spaceHalf;
float bottom = x + 0.5f - spaceHalf;
float left = y >= from ? y : from;
float right = y <= from ? y : from;
mBarRect.set(left, top, right, bottom);
trans.rectValueToPixel(mBarRect, mAnimator.getPhaseY());
}
@Override
public float[] getTransformedValues(Transformer trans, ArrayList<BarEntry> entries,
int dataSetIndex) {
return trans.generateTransformedValuesHorizontalBarChart(entries, dataSetIndex,
mChart.getBarData(), mAnimator.getPhaseY());
}
@Override
protected void drawValue(Canvas c, float val, float xPos, float yPos, ValueFormatter formatter) {
super.drawValue(c, val, xPos, yPos + mYOffset, formatter);
}
@Override
protected boolean passesCheck() {
return mChart.getBarData().getYValCount() < mChart.getMaxVisibleCount()
* mViewPortHandler.getScaleY();
}
}
| [
"phil.jahoda@gmail.com"
] | phil.jahoda@gmail.com |
3e55e69e39c28f0ea09f2f8d6994696eadf0e5db | 5e27a908a5aad2f5d071d6a6a0042d72e385b7e3 | /src/happy/dto/UserInfoDAO.java | c8dbaef7f945c460e9762c0ff4bf904382b45f92 | [] | no_license | IcarusLc/Motal168 | d2836a260331a039b20b2ee0f16270c358523175 | 132783426e0407d50139bd9cb4fb238759037907 | refs/heads/master | 2021-01-01T04:12:55.067811 | 2016-05-01T04:48:31 | 2016-05-01T04:48:31 | 57,499,006 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,820 | java | package com.happy.dao;
import java.sql.*;
import com.happy.util.*;
import com.happy.dto.*;
public class UserInfoDAO {
public boolean findUser(UserInfoDTO user)
{
Connection conn=null;
PreparedStatement state=null;
ResultSet rs=null;
try{
conn=DBUtil.getConnection();
state=conn.prepareStatement("select * from UserInfo where userID=? and userPassword=?");
state.setString(1,user.getUserID());
state.setString(2,user.getUserPassword());
rs=state.executeQuery();
if(rs.next())
{
return true;
}
else{
return false;
}
}
catch(Exception e)
{
return false;
}
finally
{
try
{
rs.close();
state.close();
conn.close();
}
catch(Exception e)
{ }
}
}
public int addUser(UserInfoDTO user)
{
Connection conn=null;
PreparedStatement state=null;
int flag=0;
try{
conn=DBUtil.getConnection();
state=conn.prepareStatement("insert into UserInfo values(?,?,?,?,?,?,?)");
state.setString(1,user.getUserID());
state.setString(2,user.getUserPassword());
state.setString(3,user.getUserSex());
state.setInt(4,user.getUserAge());
state.setString(5,user.getUserProvince());
state.setString(6,user.getUserHabit());
state.setString(7,user.getUserIntro());;
flag=state.executeUpdate();
return flag;
}
catch(Exception e)
{
return 0;
}
finally{
try{
state.close();
conn.close();
}
catch(Exception e)
{
}
}
}
public int removeUser(String id)
{
Connection conn=null;
PreparedStatement state=null;
return 0;
}
public int updateUser(UserInfoDTO user)
{
return 0;
}
} | [
"Icarus2436@163.com"
] | Icarus2436@163.com |
b604350c8f06ac945f4ae757814b0985fd5048c9 | 7f71bb27e7e0edb4477e35a7cd8e216bfca88de0 | /MyCupCakeShop/src/main/java/presentation/LoginServlet.java | bf49cfe2c31a2a6397d9cbf4276da9e01fc6a027 | [] | no_license | drh89/SchoolProjects | dbf6a6c507ef96fa3d9a98106b58589bdc91c9b2 | bef33c444f10305abe136866db36ceb3fe6c478b | refs/heads/master | 2020-04-25T21:43:27.585891 | 2019-03-17T18:44:26 | 2019-03-17T18:44:26 | 173,088,727 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 5,477 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package presentation;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import logic.OrderMapperFacade;
import logic.ShoppingCart;
import logic.User;
import logic.UserMapperFacade;
import logic.UserValidate;
/**
*
* @author Dennis
*/
@WebServlet(name = "LoginServlet", urlPatterns = {"/LoginServlet"})
public class LoginServlet extends HttpServlet {
private UserMapperFacade umf;
private UserValidate uv;
private OrderMapperFacade omf;
/**
*
* @throws Exception
*/
public LoginServlet() throws Exception {
umf = new UserMapperFacade();
uv = new UserValidate();
omf = new OrderMapperFacade();
}
/**
*
* @param request
* @param response
* @throws ServletException
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
try {
loginRequest(request, response);
} catch (Exception ex) {
ex.getStackTrace();
}
}
/**
*
* @param request
* @param response
* @throws ServletException
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
try {
newUserRequest(request, response);
} catch (SQLException ex) {
ex.getStackTrace();
} catch (ClassNotFoundException ex) {
ex.getStackTrace();
}
}
/**
*
* @param request
* @param response
* @throws SQLException
* @throws IOException
* @throws ClassNotFoundException
*
*
*
*
*/
//
// * Called if user is trying to create a new user.
// *
// * Pages:
// * NewUserPage.jsp
// * ErrorPageNewUser.jsp
// * NewUserCreated.jsp
// *
// * Forms:
// * NewUserPage.jsp
protected void newUserRequest(HttpServletRequest request, HttpServletResponse response)
throws SQLException, IOException, ClassNotFoundException {
String email = request.getParameter("email");
String username = request.getParameter("username");
String password = request.getParameter("password");
User user = new User(username, password, email);
HttpSession session = request.getSession();
if (!uv.validNewUser(user)) {
session.setAttribute("errormessage", "invalid username or email, try again");
response.sendRedirect("ErrorPageNewUser.jsp");
}
if (uv.validNewUser(user)) {
umf.newUser(user);
response.sendRedirect("NewUserCreatedPage.jsp");
}
}
/**
*
* @param request
* @param response
* @throws ServletException
* @throws IOException
* @throws Exception
*
* Called if user is trying to log in
*
*/
// * Forms:
// * LoginPage.jsp
// * ErrorPageAddCupcake.jsp
// * FundsAdded.jsp
// * OrderLineRemoved.jsp
// * OrderComplete.jsp
// * UserPaymentPage.jsp
// * AddFundsPage.jsp
// *
// * Pages:
// * UserPage.jsp
// * AdminPage.jsp
// * ErrorPage.jsp
protected void loginRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException, Exception {
//Getting parameters from index.html
String email = request.getParameter("email");
String password = request.getParameter("password");
User user = new User(email, password);
HttpSession session = request.getSession();
if (!uv.userIsValid(user)) {
//redirects to ErrorPage
response.sendRedirect("ErrorPage.jsp");
}
if (uv.userIsValid(user)) {
ShoppingCart cart = new ShoppingCart();
user = umf.getUser(user);
cart.setOrderlines(omf.getUnfinishedOrderLines(cart, user)); //Replaces the OrderLine array in cart with new array with the users unfinished orders.
session.setAttribute("user", user); //saves the user to the session
session.setAttribute("cart", cart); //saves the cart to the session
if (uv.isAdmin(user)) {
//Forwards to AdminPage
session.setAttribute("user", user);
// request.getRequestDispatcher("AdminPage.jsp").forward(request, response);
response.sendRedirect("AdminPage.jsp");
}
//Forwards to UserPager
request.getRequestDispatcher("UserPage.jsp").forward(request, response);
}
}
/**
*
* @return
*/
@Override
public String getServletInfo() {
return "Short description";
}
}
| [
"drh89@live.com"
] | drh89@live.com |
d5ec5ae2f2c7eb29a35d292bbf5990c1cf2d553a | 3abd72fc6e25e11b444d472ee29ac9ef84603b73 | /src/main/java/by/creepid/algorithms/basic/uf/UnionFindingFastUnion.java | 7ba31816ee3823154d78b9a48c8d36a927ddd50a | [] | no_license | rusakovichma/algorithms-research | 3cd0a69d85fdebc1e51dd819da9b9c9d137b65c1 | 74e43d6eb9e3cd9dcb99aa9ba9025afe13fb240a | refs/heads/master | 2021-05-30T17:38:55.354474 | 2016-03-02T17:08:24 | 2016-03-02T17:08:24 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,342 | java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package by.creepid.algorithms.basic.uf;
/**
*
* @author mirash
*
* Result structure - tree (id[] - forest trees, binding by parent links) NB:
* faster than fast search algorithm fast() - best case: 1 appeal to id[], worst
* case - (2N-1) appeal
*
* Improvement: faster then linear union() execution of FastSearch.
*
* Common array appeals count while find execution(): for N pairs (p, q) is
* 2(1+2+...+N) ~ N^2
*/
public class UnionFindingFastUnion extends UnionFindingFastSearch {
public UnionFindingFastUnion(int n) {
super(n);
}
/**
* Searching for root of p, for example find(5) -> id[id[id[5]]] in [1 1 1 8
* 3 0 5 1 8 8]
*
* @param p component
* @return root name of p
*/
@Override
public int find(int p) {
while (p != id[p]) {
p = id[p];
}
return p;
}
/**
* Fast union method
*
* @param p component
* @param q component
*/
@Override
public void union(int p, int q) {
//bring p and q to a common root
int pRoot = find(p);
int qRoot = find(q);
if (pRoot == qRoot) {
return;
}
id[pRoot] = qRoot;
count--;
}
}
| [
"mikhail.complete@gmail.com"
] | mikhail.complete@gmail.com |
f313fbdbfa4cc8cf85eb39fd621fd8db256c8dc6 | c2543b00946fd03cb1a57eb7328a047c6ae46093 | /ymPrac-jvm/ymPrac-script/ymPrac-script-js/src/main/java/com/ymPrac/script/js/JSDemo.java | 73d481b8a062ca8eed2a141b3002f43086f33c29 | [] | no_license | ympro/ymPrac | 2dc0f78c6b4628a67f2e9e0be73fe0332f24dec5 | b7ce1fc29411de9706d098901507a9b7c9c9fcbf | refs/heads/master | 2020-04-06T19:31:48.184818 | 2018-09-11T01:17:09 | 2018-09-11T01:17:09 | 59,533,702 | 1 | 1 | null | 2018-04-16T08:16:40 | 2016-05-24T02:24:32 | Java | UTF-8 | Java | false | false | 549 | java | package com.ymPrac.script.js;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
/**
* js demo
* Created by Yan Meng on 2017/7/5.
*/
public class JSDemo {
public static void main(String[] args) throws Exception {
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName( "JavaScript" );
System.out.println( engine.getClass().getName() );
System.out.println( "Result:" + engine.eval( "function f() { return 1; }; f() + 1;" ) );
}
}
| [
"yanmeng@lianjia.com"
] | yanmeng@lianjia.com |
4644f23ea0e793b375fa11391014f21a2377b8ec | fa91450deb625cda070e82d5c31770be5ca1dec6 | /Diff-Raw-Data/16/16_a22e7e880ebfa19a430ac5dc9db440d713283e51/QuickSearchAction/16_a22e7e880ebfa19a430ac5dc9db440d713283e51_QuickSearchAction_t.java | dc2d670c005eb21e1a83aad5a575bdb7ee644a92 | [] | no_license | zhongxingyu/Seer | 48e7e5197624d7afa94d23f849f8ea2075bcaec0 | c11a3109fdfca9be337e509ecb2c085b60076213 | refs/heads/master | 2023-07-06T12:48:55.516692 | 2023-06-22T07:55:56 | 2023-06-22T07:55:56 | 259,613,157 | 6 | 2 | null | 2023-06-22T07:55:57 | 2020-04-28T11:07:49 | null | UTF-8 | Java | false | false | 11,455 | java | package gov.nih.nci.nautilus.ui.struts.action;
import gov.nih.nci.nautilus.constants.NautilusConstants;
import gov.nih.nci.nautilus.de.GeneIdentifierDE;
import gov.nih.nci.nautilus.de.SNPIdentifierDE;
import gov.nih.nci.nautilus.resultset.kaplanMeierPlot.KMPlotManager;
import gov.nih.nci.nautilus.resultset.kaplanMeierPlot.KaplanMeierPlotContainer;
import gov.nih.nci.nautilus.ui.graph.geneExpression.GeneExpressionGraphGenerator;
import gov.nih.nci.nautilus.ui.graph.kaplanMeier.KMGraphGenerator;
import gov.nih.nci.nautilus.ui.graph.kaplanMeier.KMSampleInfo;
import gov.nih.nci.nautilus.ui.helper.KMDataSetHelper;
import gov.nih.nci.nautilus.ui.struts.form.KMDataSetForm;
import gov.nih.nci.nautilus.ui.struts.form.QuickSearchForm;
import gov.nih.nci.nautilus.ui.struts.form.UIFormValidator;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.log4j.Logger;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
public class QuickSearchAction extends DispatchAction {
static Logger logger = Logger.getLogger(QuickSearchAction.class);
private KaplanMeierPlotContainer kmResultsContainer = null;
private String chartType;
private String quickSearchName;
private String quickSearchType;
private String kmplotType;
/**
* Method execute
*
* @param ActionMapping
* mapping
* @param ActionForm
* form
* @param HttpServletRequest
* request
* @param HttpServletResponse
* response
* @return ActionForward
* @throws Exception
*/
private ActionForward doGeneExpPlot(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
GeneExpressionGraphGenerator generator = new GeneExpressionGraphGenerator(
form);
if (generator.getErrors().size() > 0) {
this.saveErrors(request, generator.getErrors());
return mapping.findForward("badgraph");
}
generator.setRequestAttributes(request);
generator.setSessionAttributes(request.getSession(true));
return mapping.findForward("histogram");
}
/***************************************************************************
* This method gathers the input parameters from the quickSearchForm and
* creates and forwards the request to the KMPlot jsp.
*
* @param mapping
* @param form
* @param request
* @param response
* @return
* @throws Exception
*/
public ActionForward doKMPlot(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
KMDataSetForm kmForm = (KMDataSetForm) form;
quickSearchName = (String)request.getAttribute("quickSearchName");
quickSearchType = (String)request.getAttribute("quickSearchType");
kmplotType = (String)request.getAttribute("plotType");
if(kmplotType.equals(NautilusConstants.GENE_EXP_KMPLOT)){
performKMGeneExpressionQuery(quickSearchName);
if(getKmResultsContainer() != null){
KMSampleInfo[] kmSampleInfos = getKmResultsContainer().getSummaryKMPlotSamples();
KMGraphGenerator generator = new KMGraphGenerator(kmForm.getUpFold(),
kmForm.getDownFold(), quickSearchName, kmSampleInfos, kmplotType);
if (generator.getMyActionErrors().size() > 0) {
this.saveErrors(request, generator.getMyActionErrors());
return mapping.findForward("badgraph");
}
kmForm.setGeneOrCytoband(getKmResultsContainer().getGeneSymbol().getValue().toString() );
kmForm = KMDataSetHelper.populateKMDataSetForm(generator,kmplotType, kmForm);
kmForm = KMDataSetHelper.populateReporters(getKmResultsContainer().getAssociatedReporters(),kmplotType, kmForm);
return mapping.findForward("kmplot");
}
return mapping.findForward("badgraph");
}
else if(kmplotType.equals(NautilusConstants.COPY_NUMBER_KMPLOT)){
performKMCopyNumberQuery(quickSearchName, quickSearchType);
//kmForm.setReporters(populateReporters());
if(getKmResultsContainer() != null){
String cytobandGeneSymbol = getKmResultsContainer().getCytobandDE().getValue().toString();
kmForm.setGeneOrCytoband(quickSearchName +"("+cytobandGeneSymbol+")");
KMSampleInfo[] kmSampleInfos = {new KMSampleInfo(0,0,0)};
KMGraphGenerator generator = new KMGraphGenerator(kmForm.getUpFold(),
kmForm.getDownFold(), quickSearchName, kmSampleInfos, kmplotType);
if (generator.getMyActionErrors().size() > 0) {
this.saveErrors(request, generator.getMyActionErrors());
return mapping.findForward("badgraph");
}
kmForm = KMDataSetHelper.populateKMDataSetForm(generator,kmplotType, kmForm);
kmForm = KMDataSetHelper.populateReporters(getKmResultsContainer().getAssociatedReporters(),kmplotType, kmForm);
return mapping.findForward("kmplot");
}
}
ActionErrors errors = new ActionErrors();
errors
.add(
ActionErrors.GLOBAL_ERROR,
new ActionError(
"gov.nih.nci.nautilus.ui.struts.form.quicksearch.noRecord",
quickSearchName));
this.saveErrors(request, errors);
return mapping.findForward("badgraph");
}
public ActionForward redrawKMPlot(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
KMDataSetForm kmForm = (KMDataSetForm) form;
KMSampleInfo[] kmSampleInfos = null;
//kmForm.setReporters(populateReporters());
if( getKmResultsContainer() != null &&
kmForm.getSelectedReporter() != null){
if((kmForm.getSelectedReporter().trim().length() > 0)){
if(kmplotType.equals(NautilusConstants.GENE_EXP_KMPLOT)){
if(kmForm.getSelectedReporter().equals(NautilusConstants.GRAPH_DEFAULT)){
kmSampleInfos = kmResultsContainer.getSummaryKMPlotSamples();
}
else{
kmSampleInfos = kmResultsContainer.getKMPlotSamplesForReporter(kmForm.getSelectedReporter());
}
}
else if(kmplotType.equals(NautilusConstants.COPY_NUMBER_KMPLOT)){
kmSampleInfos = kmResultsContainer.getKMPlotSamplesForReporter(kmForm.getSelectedReporter());
}
}
else{ //empty graph
KMSampleInfo[] km = {new KMSampleInfo(0,0,0)};
kmSampleInfos = km;
}
KMGraphGenerator generator = new KMGraphGenerator(kmForm.getUpFold(),
kmForm.getDownFold(), kmForm.getGeneOrCytoband(),kmSampleInfos,kmplotType);
if (generator.getMyActionErrors().size() > 0) {
this.saveErrors(request, generator.getMyActionErrors());
return mapping.findForward("badgraph");
}
//kmForm.setCensorDataset(generator.getCensorDataseries());
//kmForm.setLineDataset(generator.getLineDataseries());
kmForm = KMDataSetHelper.populateKMDataSetForm(generator,kmplotType, kmForm);
kmForm = KMDataSetHelper.populateReporters(getKmResultsContainer().getAssociatedReporters(),kmplotType, kmForm);
return mapping.findForward("kmplot");
}
return mapping.findForward("badgraph");
}
public ActionForward quickSearch(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
QuickSearchForm qsForm = (QuickSearchForm) form;
ActionErrors errors = new ActionErrors();
errors = UIFormValidator.validateGeneSymbol(qsForm, errors);
if(errors.isEmpty()){
chartType = qsForm.getPlot();
if (chartType.equalsIgnoreCase("kapMaiPlotGE")) {
logger.debug("user requested geneExp kapMai w/ genesymbol");
request.setAttribute("quickSearchName", qsForm.getQuickSearchName());
request.setAttribute("plotType", NautilusConstants.GENE_EXP_KMPLOT);
return mapping.findForward("kmplot");
}if (chartType.equalsIgnoreCase("kapMaiPlotCN")) {
logger.debug("user rquested SNP kapMaiPlotCN");
request.setAttribute("quickSearchType",qsForm.getQuickSearchType());
request.setAttribute("quickSearchName", qsForm.getQuickSearchName());
request.setAttribute("plotType", NautilusConstants.COPY_NUMBER_KMPLOT);
return mapping.findForward("kmplot");
}
else if (chartType.equalsIgnoreCase("geneExpPlot")) {
try {
logger.debug("user has requested geneExpPlot");
return doGeneExpPlot(mapping, qsForm, request, response);
} catch (Exception e) {
logger.error("Gene Expression Plot Flopped");
logger.error(e);
return mapping.findForward("error");
}
}
}
this.saveErrors(request, errors);
return mapping.findForward("mismatch");
}
/*private List populateReporters(){
List reporters = new ArrayList();
reporters.add("");
if( getKmResultsContainer() != null){
reporters = kmResultsContainer.getAssociatedReporters();
if (kmplotType.equals(NautilusConstants.GENE_EXP_KMPLOT)){
reporters.add(0,NautilusConstants.GRAPH_DEFAULT);
}
if (kmplotType.equals(NautilusConstants.COPY_NUMBER_KMPLOT)){
reporters.add(0," ");
}
}
return reporters;
}*/
/**
* @return Returns the kmResultsContainer.
* @throws Exception
*/
private void performKMGeneExpressionQuery(String geneSymbol) throws Exception {
KMPlotManager kmPlotManager = new KMPlotManager();
this.kmResultsContainer = (KaplanMeierPlotContainer) kmPlotManager.performKMGeneExpressionQuery(geneSymbol);
}
/**
* @return Returns the kmResultsContainer.
* @throws Exception
*/
private void performKMCopyNumberQuery(String name, String type) throws Exception {
KMPlotManager kmPlotManager = new KMPlotManager();
if(type.equals(NautilusConstants.GENE_SYMBOL)){
GeneIdentifierDE.GeneSymbol genesymbolDE = new GeneIdentifierDE.GeneSymbol(name);
this.kmResultsContainer = (KaplanMeierPlotContainer) kmPlotManager.performKMCopyNumberQuery(genesymbolDE);
}
/**TODO:FOr 1.0
if(type.equals(NautilusConstants.CYTOBAND)){
CytobandDE cytobandDE = new CytobandDE(name);
this.kmResultsContainer = kmPlotManager.performKMCopyNumberQuery(cytobandDE);
}
**/
if(type.equals(NautilusConstants.SNP_PROBESET_ID)){
SNPIdentifierDE.SNPProbeSet snpDE = new SNPIdentifierDE.SNPProbeSet(name);
this.kmResultsContainer = (KaplanMeierPlotContainer) kmPlotManager.performKMCopyNumberQuery(snpDE);
}
}
/**
* @return Returns the kmResultsContainer.
*/
public KaplanMeierPlotContainer getKmResultsContainer() {
return this.kmResultsContainer;
}
}
| [
"yuzhongxing88@gmail.com"
] | yuzhongxing88@gmail.com |
e43c5c05f8221149ae0e5d11be199e2f59dc14d6 | d4eef7f3fb6defc21a867492607745f5ef552057 | /study-spring/src/main/java/study_day01/main/Test_2.java | 841fb5a0e3a6e945810da233e3c62d2004691064 | [] | no_license | xiaoding18/studies | c5cad216f1b6cfe905a680f07bddf7db6d3a2fac | e958122860978ab69576f2ad059158a1e5d3b204 | refs/heads/master | 2020-03-18T08:12:37.881008 | 2018-05-23T03:46:55 | 2018-05-23T03:46:55 | 134,496,523 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,183 | java | package study_day01.main;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import study_day01.entity.Customer;
/**
* @Description:测试spring的复合类型注入
* @author xiaoding
* @date 2018年3月20日 下午3:56:09
*/
public class Test_2 {
//需要做的就是向这个List中注入三个Customer对象
private List<Customer> customerList;
//将三个Customer对象注入map中
private Map<String,Customer> map;
@Test
public void Test1() {
//先创建本例对象
ApplicationContext context = new ClassPathXmlApplicationContext("study_day01/applicationContext.xml");
Test_2 test_2 = context.getBean(this.getClass());
//分别输出List和map中的内容,查看是否符合要求
test_2.customerList.forEach(System.out::println);
test_2.map.forEach((x,y) -> System.out.println(x+""+y));
}
//提供一下setter
public void setCustomerList(List<Customer> customerList) {
this.customerList = customerList;
}
public void setMap(Map<String, Customer> map) {
this.map = map;
}
}
| [
"1192862531@qq.com"
] | 1192862531@qq.com |
eaa9e52cd1c4bae3942edce899488e842139b594 | fa91450deb625cda070e82d5c31770be5ca1dec6 | /Diff-Raw-Data/3/3_2b358050f489a2235d90008583f559353e9a8c87/L/3_2b358050f489a2235d90008583f559353e9a8c87_L_s.java | 93dca4ab98c6d54520b2bebb2fc4b289f245b712 | [] | no_license | zhongxingyu/Seer | 48e7e5197624d7afa94d23f849f8ea2075bcaec0 | c11a3109fdfca9be337e509ecb2c085b60076213 | refs/heads/master | 2023-07-06T12:48:55.516692 | 2023-06-22T07:55:56 | 2023-06-22T07:55:56 | 259,613,157 | 6 | 2 | null | 2023-06-22T07:55:57 | 2020-04-28T11:07:49 | null | UTF-8 | Java | false | false | 4,688 | java | /**
* Copyright 2012 Alex Yanchenko
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.droidparts.util;
import static android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE;
import static android.content.pm.PackageManager.GET_META_DATA;
import static org.droidparts.contract.Constants.TAG;
import org.droidparts.contract.Constants.ManifestMeta;
import org.droidparts.inject.Injector;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.util.Log;
public class L {
private static final int VERBOSE = Log.VERBOSE;
private static final int DEBUG = Log.DEBUG;
private static final int INFO = Log.INFO;
private static final int WARN = Log.WARN;
private static final int ERROR = Log.ERROR;
private static final int ASSERT = Log.ASSERT;
private static final int DISABLE = 1024;
public static void v(Object obj) {
log(VERBOSE, obj);
}
public static void d(Object obj) {
log(DEBUG, obj);
}
public static void i(Object obj) {
log(INFO, obj);
}
public static void w(Object obj) {
log(WARN, obj);
}
public static void e(Object obj) {
log(ERROR, obj);
}
public static void wtf(Object obj) {
log(ASSERT, "WTF: " + obj);
}
public static void wtf() {
log(ASSERT, "WTF");
}
private static void log(int priority, Object obj) {
boolean debug = isDebug();
if (debug || (!debug && priority >= getLogLevel())) {
String msg = (obj instanceof Exception) ? Log
.getStackTraceString((Exception) obj) : String.valueOf(obj);
Log.println(priority, getTag(debug), msg);
}
}
private static boolean isDebug() {
if (_debug == null) {
Context ctx = Injector.getApplicationContext();
if (ctx != null) {
ApplicationInfo appInfo = ctx.getApplicationInfo();
_debug = (appInfo.flags & FLAG_DEBUGGABLE) != 0;
}
}
return (_debug != null && _debug);
}
private static int getLogLevel() {
if (_logLevel == 0) {
Context ctx = Injector.getApplicationContext();
if (ctx != null) {
PackageManager pm = ctx.getPackageManager();
String logLevelStr = null;
try {
Bundle metaData = pm.getApplicationInfo(
ctx.getPackageName(), GET_META_DATA).metaData;
logLevelStr = metaData.getString(ManifestMeta.LOG_LEVEL);
} catch (Exception e) {
Log.d(TAG, "", e);
}
if (ManifestMeta.DISABLE.equalsIgnoreCase(logLevelStr)) {
_logLevel = DISABLE;
} else if (ManifestMeta.VERBOSE.equalsIgnoreCase(logLevelStr)) {
_logLevel = VERBOSE;
} else if (ManifestMeta.DEBUG.equalsIgnoreCase(logLevelStr)) {
_logLevel = DEBUG;
} else if (ManifestMeta.INFO.equalsIgnoreCase(logLevelStr)) {
_logLevel = INFO;
} else if (ManifestMeta.WARN.equalsIgnoreCase(logLevelStr)) {
_logLevel = WARN;
} else if (ManifestMeta.ERROR.equalsIgnoreCase(logLevelStr)) {
_logLevel = ERROR;
} else if (ManifestMeta.ASSERT.equalsIgnoreCase(logLevelStr)) {
_logLevel = ASSERT;
} else {
_logLevel = DISABLE;
Log.i(TAG,
"No <meta-data android:name=\"droidparts_log_level\" android:value=\"...\"/> in AndroidManifest.xml. Logging disabled.");
}
}
}
return (_logLevel != 0) ? _logLevel : DISABLE;
}
private static String getTag(boolean debug) {
if (debug) {
StackTraceElement caller = Thread.currentThread().getStackTrace()[5];
String c = caller.getClassName();
String className = c.substring(c.lastIndexOf(".") + 1, c.length());
StringBuilder sb = new StringBuilder(5);
sb.append(className);
sb.append(".");
sb.append(caller.getMethodName());
sb.append("():");
sb.append(caller.getLineNumber());
return sb.toString();
} else {
if (_tag == null) {
Context ctx = Injector.getApplicationContext();
if (ctx != null) {
_tag = ctx.getPackageName();
}
}
return (_tag != null) ? _tag : "";
}
}
private static Boolean _debug;
private static int _logLevel;
private static String _tag;
private L() {
}
}
| [
"yuzhongxing88@gmail.com"
] | yuzhongxing88@gmail.com |
25c485dfa0f002f2f600844cbe511ed4ea8b9f46 | 27b052c54bcf922e1a85cad89c4a43adfca831ba | /src/android/support/v4/app/ActivityCompat.java | 3adf2f7b46cc591d90bde5ed6c03e074f254704e | [] | no_license | dreadiscool/YikYak-Decompiled | 7169fd91f589f917b994487045916c56a261a3e8 | ebd9e9dd8dba0e657613c2c3b7036f7ecc3fc95d | refs/heads/master | 2020-04-01T10:30:36.903680 | 2015-04-14T15:40:09 | 2015-04-14T15:40:09 | 33,902,809 | 3 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,416 | java | package android.support.v4.app;
import android.app.Activity;
import android.content.Intent;
import android.os.Build.VERSION;
import android.os.Bundle;
import android.support.v4.content.ContextCompat;
public class ActivityCompat
extends ContextCompat
{
private static ActivityCompat21.SharedElementCallback21 createCallback(SharedElementCallback paramSharedElementCallback)
{
ActivityCompat.SharedElementCallback21Impl localSharedElementCallback21Impl = null;
if (paramSharedElementCallback != null) {
localSharedElementCallback21Impl = new ActivityCompat.SharedElementCallback21Impl(paramSharedElementCallback);
}
return localSharedElementCallback21Impl;
}
public static void finishAffinity(Activity paramActivity)
{
if (Build.VERSION.SDK_INT >= 16) {
ActivityCompatJB.finishAffinity(paramActivity);
}
for (;;)
{
return;
paramActivity.finish();
}
}
public static void finishAfterTransition(Activity paramActivity)
{
if (Build.VERSION.SDK_INT >= 21) {
ActivityCompat21.finishAfterTransition(paramActivity);
}
for (;;)
{
return;
paramActivity.finish();
}
}
public static boolean invalidateOptionsMenu(Activity paramActivity)
{
if (Build.VERSION.SDK_INT >= 11) {
ActivityCompatHoneycomb.invalidateOptionsMenu(paramActivity);
}
for (boolean bool = true;; bool = false) {
return bool;
}
}
public static void postponeEnterTransition(Activity paramActivity)
{
if (Build.VERSION.SDK_INT >= 21) {
ActivityCompat21.postponeEnterTransition(paramActivity);
}
}
public static void setEnterSharedElementCallback(Activity paramActivity, SharedElementCallback paramSharedElementCallback)
{
if (Build.VERSION.SDK_INT >= 21) {
ActivityCompat21.setEnterSharedElementCallback(paramActivity, createCallback(paramSharedElementCallback));
}
}
public static void setExitSharedElementCallback(Activity paramActivity, SharedElementCallback paramSharedElementCallback)
{
if (Build.VERSION.SDK_INT >= 21) {
ActivityCompat21.setExitSharedElementCallback(paramActivity, createCallback(paramSharedElementCallback));
}
}
public static void startActivity(Activity paramActivity, Intent paramIntent, Bundle paramBundle)
{
if (Build.VERSION.SDK_INT >= 16) {
ActivityCompatJB.startActivity(paramActivity, paramIntent, paramBundle);
}
for (;;)
{
return;
paramActivity.startActivity(paramIntent);
}
}
public static void startActivityForResult(Activity paramActivity, Intent paramIntent, int paramInt, Bundle paramBundle)
{
if (Build.VERSION.SDK_INT >= 16) {
ActivityCompatJB.startActivityForResult(paramActivity, paramIntent, paramInt, paramBundle);
}
for (;;)
{
return;
paramActivity.startActivityForResult(paramIntent, paramInt);
}
}
public static void startPostponedEnterTransition(Activity paramActivity)
{
if (Build.VERSION.SDK_INT >= 21) {
ActivityCompat21.startPostponedEnterTransition(paramActivity);
}
}
}
/* Location: C:\Users\dreadiscool\Desktop\tools\classes-dex2jar.jar
* Qualified Name: android.support.v4.app.ActivityCompat
* JD-Core Version: 0.7.0.1
*/ | [
"paras@protrafsolutions.com"
] | paras@protrafsolutions.com |
ac4fa3b250d6b80d5901e5cbd7b2dd8a6bbd741e | a4d39db6f8e37c18cce66a3ed1adba64f49d3c97 | /src/com/hai/andycpp/Calculator.java | f8ceb4dc792fdbd1a4201a3b1522122891199068 | [] | no_license | fulldb/hai1 | 5a77ab2ab2343682f6aa31288ed704b5dbbaf59a | 0e996e236c164e930d52791bcdeb1b1110ca38e1 | refs/heads/master | 2023-08-31T12:53:52.137026 | 2015-09-05T10:04:10 | 2015-09-05T10:04:10 | null | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 783 | java | package com.hai.andycpp;
public class Calculator {
private static int result; // 静态变量，用于存储运行结果
public void add(int n) {
result = result + n;
}
public void substract(int n) {
result = result - 1; //Bug: 正确的应该是 result =result-n
}
public void multiply(int n) {
} // 此方法尚未写好
public void divide(int n) {
result = result / n;
}
public void square(int n) {
result = n * n;
}
public void squareRoot(int n) {
for (; ;) ; //Bug : 死循环
}
public void clear() { // 将结果清零
result = 0;
}
public int getResult() {
return result;
}
}
| [
"haitianjingyu@126.com"
] | haitianjingyu@126.com |
1bab352ba14af7e48889586524c14752d58909c4 | 52bc668d10b833c6200e00bea8eb37a4f6bf2e63 | /ServicioTecnico/src/controlador/C_Tipo.java | c12f539a251f7faf70b2610ca10206eb1e3404a9 | [] | no_license | rodrigoAb21/primer_parcial_arqui | 6ccea3af1531252aee8af2137753ff51c6eecfb7 | 47ec5b538d8cc68cd69a5e243d1aba0a1e2bd0bd | refs/heads/master | 2020-05-05T05:27:32.907691 | 2019-04-07T23:59:50 | 2019-04-07T23:59:50 | 179,753,189 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,191 | java | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package controlador;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JOptionPane;
import modelo.M_Tipo;
import vista.V_Tipo;
/**
*
* @author KAKU
*/
public class C_Tipo implements ActionListener {
private M_Tipo modelo_tipo;
private V_Tipo vista_tipo;
public C_Tipo() {
this.modelo_tipo = new M_Tipo();
this.vista_tipo = new V_Tipo();
initComponent();
}
public void initComponent(){
this.vista_tipo.btn_registrar.addActionListener(this);
this.vista_tipo.btn_editar.addActionListener(this);
this.vista_tipo.btn_eliminar.addActionListener(this);
this.vista_tipo.btn_limpiar.addActionListener(this);
this.vista_tipo.setVisible(true);
actualizarTabla();
}
private void actualizarTabla(){
vista_tipo.actualizarTabla(modelo_tipo.getTipos());
}
@Override
public void actionPerformed(ActionEvent e) {
// Registrar
if (e.getSource() == vista_tipo.btn_registrar) {
modelo_tipo.setId(Integer.parseInt(vista_tipo.txt_id.getText()));
modelo_tipo.setNombre(vista_tipo.txt_nombre.getText());
if (modelo_tipo.registrar()) {
JOptionPane.showMessageDialog(null, "Se registro un tipo");
}else {
JOptionPane.showMessageDialog(null, "No se pudo registrar un tipo");
}
vista_tipo.limpiarCampos();
actualizarTabla();
} else {
// EDITAR
if (e.getSource() == vista_tipo.btn_editar) {
modelo_tipo.setId(Integer.parseInt(vista_tipo.txt_id.getText()));
modelo_tipo.setNombre(vista_tipo.txt_nombre.getText());
if (modelo_tipo.editar()) {
JOptionPane.showMessageDialog(null, "Se edito un tipo");
}else {
JOptionPane.showMessageDialog(null, "No se pudo editar un tipo");
}
vista_tipo.limpiarCampos();
actualizarTabla();
} else {
// ELIMINAR
if (e.getSource() == vista_tipo.btn_eliminar) {
modelo_tipo.setId(Integer.parseInt(vista_tipo.txt_id.getText()));
if (modelo_tipo.eliminar()) {
JOptionPane.showMessageDialog(null, "Se elimino un tipo");
}else {
JOptionPane.showMessageDialog(null, "No se pudo eliminar un tipo");
}
vista_tipo.limpiarCampos();
actualizarTabla();
} else {
if (e.getSource() == vista_tipo.btn_limpiar) {
vista_tipo.limpiarCampos();
}
}
}
}
}
public static void main(String[] args) {
C_Tipo c = new C_Tipo();
}
}
| [
"rodrigo.abasto21@gmail.com"
] | rodrigo.abasto21@gmail.com |
95df78599aa963923a1b39f06206ed5c8dabd9aa | 40df4983d86a3f691fc3f5ec6a8a54e813f7fe72 | /app/src/main/java/com/tencent/stat/event/C1745j.java | 7cd434d38c2a906c5168b59ff40b2af04d55f9f9 | [] | no_license | hlwhsunshine/RootGeniusTrunAK | 5c63599a939b24a94c6f083a0ee69694fac5a0da | 1f94603a9165e8b02e4bc9651c3528b66c19be68 | refs/heads/master | 2020-04-11T12:25:21.389753 | 2018-12-24T10:09:15 | 2018-12-24T10:09:15 | 161,779,612 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,330 | java | package com.tencent.stat.event;
import android.content.Context;
import com.tencent.stat.NetworkManager;
import com.tencent.stat.StatSpecifyReportedInfo;
import com.tencent.stat.common.StatCommonHelper;
import com.tencent.stat.common.Util;
import org.json.JSONObject;
/* renamed from: com.tencent.stat.event.j */
public class C1745j extends C1735f {
/* renamed from: a */
private static String f5124a = null;
/* renamed from: n */
private String f5125n = null;
/* renamed from: o */
private String f5126o = null;
public C1745j(Context context, int i, StatSpecifyReportedInfo statSpecifyReportedInfo) {
super(context, i, statSpecifyReportedInfo);
this.f5125n = NetworkManager.getInstance(context).getCurNetwrokName();
if (f5124a == null) {
f5124a = StatCommonHelper.getSimOperator(context);
}
}
/* renamed from: a */
public EventType mo7924a() {
return EventType.NETWORK_MONITOR;
}
/* renamed from: a */
public void mo7939a(String str) {
this.f5126o = str;
}
/* renamed from: a */
public boolean mo7925a(JSONObject jSONObject) {
Util.jsonPut(jSONObject, "op", f5124a);
Util.jsonPut(jSONObject, "cn", this.f5125n);
jSONObject.put("sp", this.f5126o);
return true;
}
}
| [
"603820467@qq.com"
] | 603820467@qq.com |
b51ed90935def948b89ca33cac9454fac4e0e630 | 649cd36c618bb8b664e2ff2addad97c5ad667185 | /src/com/zs/InterWeb/Tcp/ChatRoom/caht01/OOPServer.java | e4eeb33962c759788d589843f8f43c3d429c8cd2 | [] | no_license | zhoushuo123/SxtJava | f74116eac133b9e3e73b4cfc638f2d4a48fabe54 | 9d784514ed70179dbfb3cfd02ca8180fd775a556 | refs/heads/master | 2022-12-25T05:28:01.989056 | 2020-10-05T13:19:06 | 2020-10-05T13:19:06 | 300,121,774 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,930 | java | package com.zs.InterWeb.Tcp.ChatRoom.caht01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @program: SxtJava
* @description: 服务端，监听客户端 接收
* 模拟登陆的服务端 单向
* 步骤：
* 1 指定端口，使用 ServerSocket创建服务器
* 2、阻塞式等待连接
* 3、操作 输入输出流操作
* 4、释放资源
* @author: 周硕
* @create: 2020-09-20 11:00
**/
public class OOPServer {
public static void main(String[] args) throws IOException {
System.out.println("-----Server-------");
// 1 指定端口，使用 ServerSocket创建服务器
ServerSocket Server = new ServerSocket(8888);
boolean isRuning = true;
// 3、操作 输入输出流操作
//System.out.println("建立了一个连接");
while (isRuning) {
// 2、阻塞式等待连接 一次accept就是一次连接
Socket client = Server.accept();
new Thread(new reServer(client)).start();
}
Server.close();
}
}
class reServer implements Runnable {
private Socket client;//套接字 管道
private DataInputStream dis;//得到的数据流
private DataOutputStream dos;//发送给客户端的数据流
String datas = "";//得到的数据流转化成字符流
//初始化
public reServer(Socket client) {
this.client = client;
System.out.println("建立了一个连接");
try {
dis = new DataInputStream(client.getInputStream());
dos = new DataOutputStream(client.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
try {
client.close();
} catch (IOException ioException) {
ioException.printStackTrace();
}
}
}
//实习业务逻辑
public void run() {
String usname = "";
String uspass = "";
String[] dataArrry = rely().split("&");
for (String info : dataArrry) {
String[] useinfo = info.split("=");
if (useinfo[0].equals("usname")) {//正确的登陆业务逻辑，在这的判断应该和数据库里的判断
System.out.println("你的用户名=" + useinfo[1]);
usname = useinfo[1];
} else if (useinfo[0].equals("uspass")) {
System.out.println("你的密码=" + useinfo[1]);//此处应该进行加密
uspass = useinfo[1];
}
}
if (usname.equals("zs") && uspass .equals("zs123") ) {
send("登陆成功");
} else {
send("登陆失败");
}
release();
}
//接收数据
public String rely() {
try {
datas = dis.readUTF();
return datas;
} catch (IOException e) {
e.printStackTrace();
}
return datas;
}
//返回客户端信息
public void send(String msg) {
try {
dos.writeUTF(msg);//返回给客户端信息
dos.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
//释放资源
public void release() {
try {
if(null !=dis){
dis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(null !=dos){
dos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
client.close();
} catch (IOException e) {
e.printStackTrace();
}
/**
try {
dis.close();
dos.close();
client.close();
} catch (IOException e) {
e.printStackTrace();
}**/
}
}
| [
"627229471@qq.com"
] | 627229471@qq.com |
34683c2276f72e4a07fe8cc10406a8bb20765297 | d2b56bba8665da6c9d704b8c47dd16112770c5f1 | /spring-07-appconfig/src/test/java/MyTest.java | 797ce3bcdaf509bd49d566cec0dd3cac13a9a1be | [] | no_license | diandian2710/Spring | 872a646e077732db6d950967dc817658412ee34c | b27c9a2d342b8803bf215117f6fa88dc01af111d | refs/heads/master | 2022-12-05T06:55:16.823033 | 2020-09-02T23:43:21 | 2020-09-02T23:43:21 | 291,384,358 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 710 | java | import com.kuang.config.MyConfig;
import com.kuang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
//如果完全使用了配置类方式去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
User getUser = context.getBean("getUser", User.class);
System.out.println(getUser.getName());
}
}
| [
"wxh604328815@gmail.com"
] | wxh604328815@gmail.com |
33b0f88e33eb2498152bec243a0c9b324a84a7eb | 9b1461b0eb77334f956f82bd2a6db9ad2e7229ee | /chap3_pattern/src/edu/jaen/java/adapter_inheritance/Print.java | 7942a11d2ded738adf55487422235322a30c3eb7 | [] | no_license | apostlez/ClassEx_JavaIntermediate | 4a1bc53aee19499bc79ddb4ef7d155a7f42c8fe5 | 13a1b79b7cba92ceb3ef782ba99ddb1873dae143 | refs/heads/master | 2021-01-10T13:52:07.911125 | 2015-10-23T09:02:55 | 2015-10-23T09:02:55 | 44,518,673 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 155 | java | package edu.jaen.java.adapter_inheritance;
public interface Print {
public abstract void printWeak();
public abstract void printStrong();
}
| [
"hjh@TRUST11"
] | hjh@TRUST11 |
d5a3c7f3436e2cef0375b81fb54bbc5d947cb179 | c8b19d39165d506c5d455be4bd85a1d40abb2424 | /src/main/java/edu/gzhu/its/humanism/web/HumanismController.java | c371333c71deb18956a4d363578a02ffd9143f17 | [] | no_license | dinggz1982/DingDing-Tutoring-System | 2b21be75cd77afadf70bc20b3f686cf940ea3f34 | 69c245c0e1e4de3dba3e7de33953383f4892d865 | refs/heads/master | 2022-07-23T09:40:11.128802 | 2019-11-27T18:28:45 | 2019-11-27T18:28:45 | 202,401,808 | 0 | 1 | null | 2022-06-29T17:34:40 | 2019-08-14T18:07:56 | JavaScript | UTF-8 | Java | false | false | 782 | java | package edu.gzhu.its.humanism.web;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* 人文性知识图谱 入口
* <p>Title : HumanismController</p>
* <p>Description : </p>
* <p>Company : </p>
* @author 丁国柱
* @date 2018年7月11日 下午4:24:00
*/
@Controller
@RequestMapping("/humanism")
public class HumanismController {
/**
* 群体-人文性知识图谱入口
* <p>方法名:index </p>
* <p>Description : </p>
* <p>Company : </p>
* @author 丁国柱
* @date 2018年7月11日 下午4:25:10
* @return
*/
@GetMapping("/index")
public String index(){
return "humanism/index";
}
}
| [
"dgz888@163.com"
] | dgz888@163.com |
597f176f31c7e2e58dd1fd37da47a1bd98990460 | b218169eb27975819fe771b226430ac0759af53c | /Star Ticket User/src/com/ignite/mm/ticketing/user/PromotionActivity.java | 05bb71cbff2bba36235d4c265e167d7268624012 | [] | no_license | ignitemyanmar/starticketandroid | 23b40ba44040d1ea6bf238f980fc6261a3c666fa | 69c8e2ed3172f9d08489bf68cc998ffcafb2d5f9 | refs/heads/master | 2021-06-12T18:39:09.390898 | 2017-02-27T10:32:05 | 2017-02-27T10:32:05 | 37,309,842 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,293 | java | package com.ignite.mm.ticketing.user;
import java.util.ArrayList;
import java.util.List;
import retrofit.Callback;
import retrofit.RetrofitError;
import retrofit.client.Response;
import android.app.ActionBar;
import android.app.ProgressDialog;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ImageButton;
import android.widget.ListView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import com.ignite.mm.ticketing.application.BaseActivity;
import com.ignite.mm.ticketing.clientapi.NetworkEngine;
import com.ignite.mm.ticketing.custom.listview.adapter.PromotionAdapter;
import com.ignite.mm.ticketing.sqlite.database.model.Promotion;
import com.thuongnh.zprogresshud.ZProgressHUD;
public class PromotionActivity extends BaseActivity{
private ListView lv_promotion;
private ActionBar actionBar;
private TextView actionBarTitle;
private TextView actionBarTitle2;
private ImageButton actionBarBack;
private RelativeLayout layout_noPromotion;
private ZProgressHUD dialog;
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_promotion);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
if (toolbar != null) {
toolbar.setNavigationIcon(R.drawable.abc_ic_ab_back_mtrl_am_alpha);
toolbar.setTitle("ပ႐ုိမိုရွင္း");
this.setSupportActionBar(toolbar);
}
layout_noPromotion = (RelativeLayout)findViewById(R.id.layout_noPromotion);
lv_promotion = (ListView)findViewById(R.id.lv_promotion);
lv_promotion.setDividerHeight(0);
List<String> listOperatorPromo = new ArrayList<String>();
listOperatorPromo.add("မႏၱလာမင္း");
listOperatorPromo.add("Elite");
listOperatorPromo.add("ေရႊမႏၱလာ");
/*listOperatorPromo.add("မုိးေကာင္းကင္");
listOperatorPromo.add("Asia Express ");
listOperatorPromo.add("အာကာသ");
listOperatorPromo.add("တုိးရတနာ");*/
getPromo();
}
private void getPromo() {
// TODO Auto-generated method stub
dialog = new ZProgressHUD(PromotionActivity.this);
dialog.show();
NetworkEngine.getInstance().GetPromotion(new Callback<List<Promotion>>() {
public void success(List<Promotion> arg0, Response arg1) {
// TODO Auto-generated method stub
if (arg0 != null && arg0.size() > 0) {
lv_promotion.setAdapter(new PromotionAdapter(PromotionActivity.this, arg0));
}else {
layout_noPromotion.setVisibility(View.VISIBLE);
lv_promotion.setAdapter(null);
}
dialog.dismissWithSuccess();
}
public void failure(RetrofitError arg0) {
// TODO Auto-generated method stub
if (arg0.getResponse() != null) {
Log.i("", "Promo Error: "+arg0.getResponse().getStatus());
}
dialog.dismissWithFailure();
}
});
}
@Override
public Intent getSupportParentActivityIntent() {
// TODO Auto-generated method stub
finish();
return super.getSupportParentActivityIntent();
}
}
| [
"suwaiphyo1985@gmail.com"
] | suwaiphyo1985@gmail.com |
59349ec5db9ea0cea46714ae88f8b7dd582e73ef | f3207eeee72c91fe942bec59d8cfad3f38abceed | /Not important for Iteration-03/Legacy/SMD_Iteration02/src/InventoryScreenView.java | 7b6ff6df43ff3907a8317de2abbf09956ad92977 | [] | no_license | aig0003/SMD-Project-Fall-2017 | c5ec77511c50bce2f096339158e16ef79a6cb93c | d1cd7ae40687b46dade333e9654349bc3186c353 | refs/heads/master | 2020-03-29T20:54:40.764908 | 2017-12-16T19:40:20 | 2017-12-16T19:40:20 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,617 | java | //TODO: Format buttons
import javax.swing.*;
import java.awt.*;
public class InventoryScreenView extends JFrame {
// String Labels/Constants
private static int PW = 600; private static int PH = 240; // Page width & height dimension
private static int BW = 180; private static int BH = 25; // Button width & height dimensions
private static String pageTitle = "Inventory Management";
private JButton inventoryButton = new JButton("Manage Inventory");
private JButton reportButton = new JButton("Business Report");
private JButton backButton = new JButton("Back");
public InventoryScreenView() {
this.setTitle(pageTitle);
this.setLayout(new BoxLayout(this.getContentPane(), BoxLayout.Y_AXIS));
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(PW, PH);
//Set size of buttons
reportButton.setPreferredSize(new Dimension(BW, BH));
inventoryButton.setPreferredSize(new Dimension(BW, BH));
backButton.setPreferredSize(new Dimension(BW, BH));
// Buttons panel
JPanel buttonPanel = new JPanel();
buttonPanel.add(inventoryButton);
buttonPanel.add(reportButton);
// Back button panel
JPanel backButtonPanel = new JPanel();
backButtonPanel.add(backButton);
this.getContentPane().add(buttonPanel);
this.getContentPane().add(backButtonPanel);
}
public JButton getInventoryButton() { return inventoryButton; }
public JButton getReportButton() { return reportButton; }
public JButton getBackButton() { return backButton; }
}
| [
"thatcherr2@gmail.com"
] | thatcherr2@gmail.com |
60ee8f96a598e00bcf12b3594dffefd23924d153 | 2bd6cbfd84f45b9c9ff4a3655cb1ca81811bee57 | /cloudalibaba-consumer-nacos-order83/src/main/java/com/xialuo/cloud/controller/OrderNacosController.java | 3feb1b0d5cf834651085a1d256d28dd15148b0d0 | [] | no_license | 781616300/xialuo-cloud-2020 | 094dcb60dd59c7e6fdcda3937921162c021e0d49 | 103c011966927bdedda7058107c4e48d3eb73590 | refs/heads/main | 2023-03-03T04:53:18.323846 | 2021-01-04T12:45:20 | 2021-01-04T12:45:20 | 322,781,239 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 893 | java | package com.xialuo.cloud.controller;
import javax.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
/**
* @auther zzyy
* @create 2020-02-23 15:01
*/
@RestController
@Slf4j
public class OrderNacosController
{
@Resource
private RestTemplate restTemplate;
@Value("${service-url.nacos-user-service}")
private String serverURL;
@GetMapping(value = "/consumer/payment/nacos/{id}")
public String paymentInfo(@PathVariable("id") Long id)
{
return restTemplate.getForObject(serverURL+"/payment/nacos/"+id,String.class);
}
}
| [
"fengliye@xdf.cn"
] | fengliye@xdf.cn |
367ada6c022e109ac0c0163af3945edb265118a8 | 8bc3ef4d656df0f26dc6ab541c4b6638429d1fb1 | /4_OOP/src/hw1/Main.java | c24cbf82ea534bef303c09c863356d69c5d176c6 | [] | no_license | LiubomyrPodoliak/Java_Core | 6f3f3aaf248cc9ab8b397105afec51ed7ffad31b | 0689079beb3cabee60ee3ffdc165b2051acd7a1b | refs/heads/master | 2020-04-09T01:52:44.105820 | 2018-12-01T07:37:09 | 2018-12-01T07:37:09 | 159,920,558 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 356 | java | package hw1;
public class Main {
public static void main(String[] args) {
Bird[] birds = {
new Swallow(true, false),
new Eagle(true, true),
new Penguin(false, true),
new Chicken(false, true)
};
for (int i = 0; i < birds.length; i++) {
System.out.println(birds[i]);
birds[i].fly();
System.out.println();
}
}
}
| [
"L.podoliak@gmail.com"
] | L.podoliak@gmail.com |
54f7db1498b391ffcf196859942192dcf7fd36f6 | 13848276b5fa9ae81113049c6d222b95f9c68f66 | /src/main/java/org/transformer/util/Reflections.java | 8b48ba0f870d54279b725c25d5d9abb5fcc04a36 | [] | no_license | wjkyori/transformer-util | ac868e77ffb675d7266021702ed8d5b4794becef | c52d085e29dc0df0a159e08b73913c419114900d | refs/heads/master | 2021-01-19T10:17:22.268132 | 2017-05-05T05:42:21 | 2017-05-05T05:42:21 | 82,179,182 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 13,822 | java | package org.transformer.util;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* 反射工具类.
* 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数.
*
*/
public class Reflections {
/** The Constant SETTER_PREFIX. */
private static final String SETTER_PREFIX = "set";
/** The Constant GETTER_PREFIX. */
private static final String GETTER_PREFIX = "get";
/** The Constant CGLIB_CLASS_SEPARATOR. */
private static final String CGLIB_CLASS_SEPARATOR = "$$";
/** The logger. */
private static Logger logger = LoggerFactory.getLogger(Reflections.class);
/**
* 调用Getter方法.
*
* @param obj
* the obj
* @param propertyName
* the property name
* @return the object
*/
public static Object invokeGetter(Object obj, String propertyName) {
String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(propertyName);
return invokeMethod(obj, getterMethodName, new Class[] {}, new Object[] {});
}
/**
* 调用Setter方法, 仅匹配方法名。.
*
* @param obj
* the obj
* @param propertyName
* the property name
* @param value
* the value
*/
public static void invokeSetter(Object obj, String propertyName, Object value) {
String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(propertyName);
invokeMethodByName(obj, setterMethodName, new Object[] { value });
}
/**
* 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.
*
* @param obj
* the obj
* @param fieldName
* the field name
* @return the field value
*/
public static Object getFieldValue(final Object obj, final String fieldName) {
Field field = getAccessibleField(obj, fieldName);
if (field == null) {
throw new IllegalArgumentException(
"Could not find field [" + fieldName + "] on target [" + obj + "]");
}
Object result = null;
try {
result = field.get(obj);
} catch (IllegalAccessException e) {
logger.error("不可能抛出的异常{}", e.getMessage());
}
return result;
}
/**
* 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
*
* @param obj
* the obj
* @param fieldName
* the field name
* @param value
* the value
*/
public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
Field field = getAccessibleField(obj, fieldName);
if (field == null) {
throw new IllegalArgumentException(
"Could not find field [" + fieldName + "] on target [" + obj + "]");
}
try {
field.set(obj, value);
} catch (IllegalAccessException e) {
logger.error("不可能抛出的异常:{}", e.getMessage());
}
}
/**
* 直接调用对象方法, 无视private/protected修饰符.
* 用于一次性调用的情况，否则应使用getAccessibleMethod()函数获得Method后反复调用. 同时匹配方法名+参数类型，
*
* @param obj
* the obj
* @param methodName
* the method name
* @param parameterTypes
* the parameter types
* @param args
* the args
* @return the object
*/
public static Object invokeMethod(final Object obj, final String methodName,
final Class<?>[] parameterTypes, final Object[] args) {
Method method = getAccessibleMethod(obj, methodName, parameterTypes);
if (method == null) {
throw new IllegalArgumentException(
"Could not find method [" + methodName + "] on target [" + obj + "]");
}
try {
return method.invoke(obj, args);
} catch (Exception e) {
throw convertReflectionExceptionToUnchecked(e);
}
}
/**
* 直接调用对象方法, 无视private/protected修饰符，
* 用于一次性调用的情况，否则应使用getAccessibleMethodByName()函数获得Method后反复调用.
* 只匹配函数名，如果有多个同名函数调用第一个。
*
* @param obj
* the obj
* @param methodName
* the method name
* @param args
* the args
* @return the object
*/
public static Object invokeMethodByName(final Object obj, final String methodName,
final Object[] args) {
Method method = getAccessibleMethodByName(obj, methodName);
if (method == null) {
throw new IllegalArgumentException(
"Could not find method [" + methodName + "] on target [" + obj + "]");
}
try {
return method.invoke(obj, args);
} catch (Exception e) {
throw convertReflectionExceptionToUnchecked(e);
}
}
/**
* 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问.
* 如向上转型到Object仍无法找到, 返回null.
*
* @param obj
* the obj
* @param fieldName
* the field name
* @return the accessible field
*/
public static Field getAccessibleField(final Object obj, final String fieldName) {
Validate.notNull(obj, "object can't be null");
Validate.notBlank(fieldName, "fieldName can't be blank");
for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass
.getSuperclass()) {
try {
Field field = superClass.getDeclaredField(fieldName);
makeAccessible(field);
return field;
} catch (NoSuchFieldException e) {
// Field不在当前类定义,继续向上转型
logger.error("no such field : {}", fieldName, e);
}
}
return null;
}
/**
* 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问. 如向上转型到Object仍无法找到, 返回null.
* 匹配函数名+参数类型。
* 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object...
* args)
*
* @param obj
* the obj
* @param methodName
* the method name
* @param parameterTypes
* the parameter types
* @return the accessible method
*/
public static Method getAccessibleMethod(final Object obj, final String methodName,
final Class<?>... parameterTypes) {
Validate.notNull(obj, "object can't be null");
Validate.notBlank(methodName, "methodName can't be blank");
for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType
.getSuperclass()) {
try {
Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
makeAccessible(method);
return method;
} catch (NoSuchMethodException e) {
// Method不在当前类定义,继续向上转型
logger.error("no such method : {}", methodName, e);
}
}
return null;
}
/**
* 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问. 如向上转型到Object仍无法找到, 返回null. 只匹配函数名。
* 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object...
* args)
*
* @param obj
* the obj
* @param methodName
* the method name
* @return the accessible method by name
*/
public static Method getAccessibleMethodByName(final Object obj, final String methodName) {
Validate.notNull(obj, "object can't be null");
Validate.notBlank(methodName, "methodName can't be blank");
for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType
.getSuperclass()) {
Method[] methods = searchType.getDeclaredMethods();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
makeAccessible(method);
return method;
}
}
}
return null;
}
/**
* 改变private/protected的方法为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。.
*
* @param method
* the method
*/
public static void makeAccessible(Method method) {
if ((!Modifier.isPublic(method.getModifiers())
|| !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
&& !method.isAccessible()) {
method.setAccessible(true);
}
}
/**
* 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。.
*
* @param field
* the field
*/
public static void makeAccessible(Field field) {
if ((!Modifier.isPublic(field.getModifiers())
|| !Modifier.isPublic(field.getDeclaringClass().getModifiers())
|| Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
field.setAccessible(true);
}
}
/**
* 通过反射, 获得Class定义中声明的泛型参数的类型, 注意泛型必须定义在父类处 如无法找到, 返回Object.class. eg.
*
* @param <T>
* the generic type
* @param clazz
* The class to introspect
* @return the first generic declaration, or Object.class if cannot be
* determined
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static <T> Class<T> getClassGenricType(final Class clazz) {
return getClassGenricType(clazz, 0);
}
/**
* 通过反射, 获得Class定义中声明的父类的泛型参数的类型. 如无法找到, 返回Object.class.
* @param clazz
* clazz The class to introspect
* @param index
* the Index of the generic ddeclaration,start from 0.
* @return the index generic declaration, or Object.class if cannot be
* determined
*/
@SuppressWarnings("rawtypes")
public static Class getClassGenricType(final Class clazz, final int index) {
Type genType = clazz.getGenericSuperclass();
if (!(genType instanceof ParameterizedType)) {
logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
return Object.class;
}
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if ((index >= params.length) || (index < 0)) {
logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName()
+ "'s Parameterized Type: " + params.length);
return Object.class;
}
if (!(params[index] instanceof Class)) {
logger.warn(
clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
return Object.class;
}
return (Class) params[index];
}
/**
* Gets the user class.
*
* @param instance
* the instance
* @return the user class
*/
@SuppressWarnings("rawtypes")
public static Class<?> getUserClass(Object instance) {
Validate.notNull(instance, "Instance must not be null");
Class clazz = instance.getClass();
if ((clazz != null) && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
Class<?> superClass = clazz.getSuperclass();
if ((superClass != null) && !Object.class.equals(superClass)) {
return superClass;
}
}
return clazz;
}
/**
* 将反射时的checked exception转换为unchecked exception.
* @param exception the exception
* @return the runtime exception
*/
public static RuntimeException convertReflectionExceptionToUnchecked(Exception exception) {
if ((exception instanceof IllegalAccessException)
|| (exception instanceof IllegalArgumentException)
|| (exception instanceof NoSuchMethodException)) {
return new IllegalArgumentException(exception);
} else if (exception instanceof InvocationTargetException) {
return new RuntimeException(((InvocationTargetException) exception).getTargetException());
} else if (exception instanceof RuntimeException) {
return (RuntimeException) exception;
}
return new RuntimeException("Unexpected Checked Exception.", exception);
}
/**
* 得到指定类型的指定位置的泛型实参.
*
* @param <T>
* the generic type
* @param clazz
* the clazz
* @param index
* the index
* @return the class
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> findParameterizedType(Class<?> clazz, int index) {
Type parameterizedType = clazz.getGenericSuperclass();
// CGLUB subclass target object(泛型在父类上)
if (!(parameterizedType instanceof ParameterizedType)) {
parameterizedType = clazz.getSuperclass().getGenericSuperclass();
}
if (!(parameterizedType instanceof ParameterizedType)) {
return null;
}
Type[] actualTypeArguments = ((ParameterizedType) parameterizedType).getActualTypeArguments();
if (actualTypeArguments == null || actualTypeArguments.length == 0) {
return null;
}
return (Class<T>) actualTypeArguments[index];
}
}
| [
"49204399@qq.com"
] | 49204399@qq.com |
77374207f98bf05d2da73d3978a330aa3cb68138 | 11cf50db9959cb031780a756d34739d7bade8ba3 | /flyweight/src/main/java/com/beauney/flyweight/Girl.java | 03612fd668e35e90afc3a36bca0cbf1ad0ebed34 | [] | no_license | zeng280091932/DesignPatternDemo | 07c2a78de4ce0dda6e746b62edb065a664f7bf11 | 2665a052d5894ef13739f8e02d509dde66264f03 | refs/heads/master | 2022-12-02T17:56:07.147879 | 2020-08-19T09:18:18 | 2020-08-19T09:18:18 | 281,058,218 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 369 | java | package com.beauney.flyweight;
/**
* @author zengjiantao
* @since 2020-08-03
*/
public abstract class Girl {
private int state;
public Girl(int state) {
this.state = state;
}
public abstract void operate();
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}
| [
"280091932@qq.com"
] | 280091932@qq.com |
0f6ea8220aa80f84f1c00e70867b3a6b39fc75e7 | 36914caab5d870d6cb27874e9d8b8a7b3e0f2728 | /src/views/TutorialPanelGameZone.java | ffed13ec044fdff4ac730cb0d6e50f7f14acf680 | [] | no_license | FredyNicolasMoreno/LastManStanding | 6922fbf98450b858d5b1bb4bf31dcb6c4f156b68 | 2fb159a2962b0ff90f75ab1c08a60eb103c636a2 | refs/heads/master | 2020-03-18T18:26:08.670718 | 2018-06-21T22:53:10 | 2018-06-21T22:53:10 | 135,092,520 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,319 | java | package views;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import javax.swing.JPanel;
import controller.Control;
public class TutorialPanelGameZone extends JPanel{
private static final long serialVersionUID = 1L;
private Rectangle player;
private Rectangle bullet;
private Rectangle guns;
public TutorialPanelGameZone(Rectangle playerLL, Rectangle gun, Rectangle bullets,Control control) {
this.addKeyListener(control);
setBackground(Color.BLACK);
player = new Rectangle(playerLL.x, playerLL.y, playerLL.width, playerLL.height);
guns = new Rectangle(gun.x, gun.y, gun.width, gun.height);
bullet = new Rectangle(bullets.x, bullets.y, bullets.width, bullets.height);
}
public void paint(Graphics g) {
super.paint(g);
g.setColor(Color.GRAY);
g.fillRect(0, 350, 1500, 50);
g.setColor(Color.YELLOW);
g.fillRect(player.x, player.y, (int)player.width, (int)player.height);
g.setColor(Color.WHITE);
g.fillRect(bullet.x, bullet.y, (int)bullet.width, (int)bullet.height);
g.setColor(Color.RED);
g.fillRect(guns.x, guns.y, (int)guns.width, (int)guns.height);
}
public void setAll(Rectangle playerLL, Rectangle gun, Rectangle bullets) {
this.player = playerLL;
this.guns = gun;
this.bullet = bullets;
repaint();
revalidate();
}
}
| [
"fredy.moreno01@uptc.edu.co"
] | fredy.moreno01@uptc.edu.co |
88525150339893682a8197c6d643e555c00bfa1b | 4d97a8ec832633b154a03049d17f8b58233cbc5d | /Chart/14/Chart/evosuite-branch/7/org/jfree/chart/plot/XYPlotEvoSuite_branch_Test.java | b077b34a3412c1016108c13afa2834ee895d2618 | [] | no_license | 4open-science/evosuite-defects4j | be2d172a5ce11e0de5f1272a8d00d2e1a2e5f756 | ca7d316883a38177c9066e0290e6dcaa8b5ebd77 | refs/heads/master | 2021-06-16T18:43:29.227993 | 2017-06-07T10:37:26 | 2017-06-07T10:37:26 | 93,623,570 | 2 | 1 | null | null | null | null | UTF-8 | Java | false | false | 1,163,147 | java | /*
* This file was automatically generated by EvoSuite
* Thu Dec 11 18:19:32 GMT 2014
*/
package org.jfree.chart.plot;
import static org.junit.Assert.*;
import org.junit.Test;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.SystemColor;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.util.Collection;
import java.util.EventListener;
import java.util.List;
import java.util.TimeZone;
import javax.swing.DefaultListCellRenderer;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JInternalFrame;
import javax.swing.JPopupMenu;
import javax.swing.plaf.ColorUIResource;
import javax.swing.tree.DefaultTreeCellRenderer;
import org.evosuite.runtime.EvoRunner;
import org.evosuite.runtime.EvoRunnerParameters;
import org.evosuite.runtime.EvoSuiteFile;
import org.evosuite.runtime.FileSystemHandling;
import org.evosuite.runtime.mock.java.lang.MockIllegalArgumentException;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.ChartRenderingInfo;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.LegendItemCollection;
import org.jfree.chart.annotations.XYAnnotation;
import org.jfree.chart.annotations.XYShapeAnnotation;
import org.jfree.chart.annotations.XYTextAnnotation;
import org.jfree.chart.axis.Axis;
import org.jfree.chart.axis.AxisLocation;
import org.jfree.chart.axis.AxisSpace;
import org.jfree.chart.axis.CategoryAxis;
import org.jfree.chart.axis.CyclicNumberAxis;
import org.jfree.chart.axis.DateAxis;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.NumberAxis3D;
import org.jfree.chart.axis.SubCategoryAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.block.EmptyBlock;
import org.jfree.chart.event.RendererChangeEvent;
import org.jfree.chart.labels.StandardXYToolTipGenerator;
import org.jfree.chart.labels.XYToolTipGenerator;
import org.jfree.chart.needle.PointerNeedle;
import org.jfree.chart.plot.CategoryMarker;
import org.jfree.chart.plot.CombinedDomainCategoryPlot;
import org.jfree.chart.plot.CombinedDomainXYPlot;
import org.jfree.chart.plot.CombinedRangeCategoryPlot;
import org.jfree.chart.plot.CombinedRangeXYPlot;
import org.jfree.chart.plot.DatasetRenderingOrder;
import org.jfree.chart.plot.FastScatterPlot;
import org.jfree.chart.plot.IntervalMarker;
import org.jfree.chart.plot.Marker;
import org.jfree.chart.plot.Plot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.PlotRenderingInfo;
import org.jfree.chart.plot.SeriesRenderingOrder;
import org.jfree.chart.plot.ValueMarker;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.AbstractRenderer;
import org.jfree.chart.renderer.category.GroupedStackedBarRenderer;
import org.jfree.chart.renderer.category.LineRenderer3D;
import org.jfree.chart.renderer.category.MinMaxCategoryRenderer;
import org.jfree.chart.renderer.category.StackedAreaRenderer;
import org.jfree.chart.renderer.category.StackedBarRenderer3D;
import org.jfree.chart.renderer.category.StatisticalBarRenderer;
import org.jfree.chart.renderer.category.StatisticalLineAndShapeRenderer;
import org.jfree.chart.renderer.xy.CandlestickRenderer;
import org.jfree.chart.renderer.xy.CyclicXYItemRenderer;
import org.jfree.chart.renderer.xy.DeviationRenderer;
import org.jfree.chart.renderer.xy.HighLowRenderer;
import org.jfree.chart.renderer.xy.StackedXYAreaRenderer2;
import org.jfree.chart.renderer.xy.StandardXYItemRenderer;
import org.jfree.chart.renderer.xy.VectorRenderer;
import org.jfree.chart.renderer.xy.XYDotRenderer;
import org.jfree.chart.renderer.xy.XYErrorRenderer;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.chart.renderer.xy.XYLine3DRenderer;
import org.jfree.chart.renderer.xy.YIntervalRenderer;
import org.jfree.chart.urls.XYURLGenerator;
import org.jfree.chart.util.Layer;
import org.jfree.chart.util.RectangleEdge;
import org.jfree.chart.util.RectangleInsets;
import org.jfree.data.general.DefaultKeyedValuesDataset;
import org.jfree.data.time.DynamicTimeSeriesCollection;
import org.jfree.data.time.RegularTimePeriod;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.xy.MatrixSeriesCollection;
import org.jfree.data.xy.VectorSeriesCollection;
import org.jfree.data.xy.XYBarDataset;
import org.jfree.data.xy.XYDataset;
import org.junit.runner.RunWith;
import sun.java2d.SunGraphics2D;
import sun.swing.ImageIconUIResource;
import sun.util.calendar.ZoneInfo;
@RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, resetStaticState = true)
public class XYPlotEvoSuite_branch_Test extends XYPlotEvoSuite_branch_Test_scaffolding {
@Test
public void test000() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot();
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertNotNull(combinedRangeCategoryPlot0);
combinedDomainXYPlot0.setRangeAxis((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
AxisLocation axisLocation0 = combinedRangeCategoryPlot0.getRangeAxisLocation(int0);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals("AxisLocation.TOP_OR_LEFT", axisLocation0.toString());
// // Unstable assertion: assertNotNull(axisLocation0);
boolean boolean0 = true;
combinedDomainXYPlot0.setDomainAxisLocation(axisLocation0, boolean0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals("AxisLocation.TOP_OR_LEFT", axisLocation0.toString());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
DynamicTimeSeriesCollection dynamicTimeSeriesCollection0 = new DynamicTimeSeriesCollection(int0, int0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getPosition());
// // Unstable assertion: assertEquals(-1, dynamicTimeSeriesCollection0.getNewestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getOldestIndex());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dynamicTimeSeriesCollection0);
XYBarDataset xYBarDataset0 = new XYBarDataset((XYDataset) dynamicTimeSeriesCollection0, (double) int0);
// // Unstable assertion: assertEquals(0.0, xYBarDataset0.getBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getPosition());
// // Unstable assertion: assertEquals(-1, dynamicTimeSeriesCollection0.getNewestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getOldestIndex());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(xYBarDataset0);
XYDotRenderer xYDotRenderer0 = new XYDotRenderer();
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(3, xYDotRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotHeight());
// // Unstable assertion: assertEquals(2.0, xYDotRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotWidth());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertNotNull(xYDotRenderer0);
XYPlot xYPlot0 = new XYPlot((XYDataset) xYBarDataset0, (ValueAxis) dateAxis0, (ValueAxis) dateAxis0, (XYItemRenderer) xYDotRenderer0);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(3, xYDotRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotHeight());
// // Unstable assertion: assertEquals(2.0, xYDotRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotWidth());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0, xYBarDataset0.getBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getPosition());
// // Unstable assertion: assertEquals(-1, dynamicTimeSeriesCollection0.getNewestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getOldestIndex());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(xYPlot0);
combinedDomainXYPlot0.setRangeAxis((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
}
@Test
public void test001() throws Throwable {
double double0 = (-3875.55);
double double1 = Line2D.ptLineDistSq(double0, double0, double0, double0, double0, double0);
assertFalse(double0 == double1);
assertFalse(double1 == double0);
assertEquals(Double.NaN, double1, 0.01D);
CandlestickRenderer candlestickRenderer0 = new CandlestickRenderer(double1);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(Double.NaN, candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertFalse(double0 == double1);
assertFalse(double1 == double0);
assertNotNull(candlestickRenderer0);
XYDataset xYDataset0 = null;
String string0 = "";
CyclicNumberAxis cyclicNumberAxis0 = new CyclicNumberAxis(double0, string0);
assertNull(cyclicNumberAxis0.getLabelToolTip());
assertEquals(true, cyclicNumberAxis0.isAutoRange());
assertEquals(false, cyclicNumberAxis0.isVerticalTickLabels());
assertEquals(0.05, cyclicNumberAxis0.getUpperMargin(), 0.01D);
assertEquals((-3875.55), cyclicNumberAxis0.getOffset(), 0.01D);
assertEquals(0.0, cyclicNumberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(1.0E-8, cyclicNumberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isInverted());
assertEquals("", cyclicNumberAxis0.getLabel());
assertEquals(true, cyclicNumberAxis0.getAutoRangeStickyZero());
assertEquals(0.0, cyclicNumberAxis0.getLowerBound(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isBoundMappedToLastCycle());
assertEquals(2.0F, cyclicNumberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(1.0, cyclicNumberAxis0.getUpperBound(), 0.01D);
assertEquals(0.0, cyclicNumberAxis0.getFixedDimension(), 0.01D);
assertNull(cyclicNumberAxis0.getLabelURL());
assertEquals(false, cyclicNumberAxis0.isNegativeArrowVisible());
assertEquals(true, cyclicNumberAxis0.isAdvanceLineVisible());
assertEquals(true, cyclicNumberAxis0.getAutoRangeIncludesZero());
assertEquals(true, cyclicNumberAxis0.isTickLabelsVisible());
assertEquals(0.0, cyclicNumberAxis0.getPeriod(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAutoTickUnitSelection());
assertEquals(0.0F, cyclicNumberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, cyclicNumberAxis0.isPositiveArrowVisible());
assertEquals(0.0, cyclicNumberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAxisLineVisible());
assertEquals(0.05, cyclicNumberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isVisible());
assertEquals(true, cyclicNumberAxis0.isTickMarksVisible());
assertFalse(double0 == double1);
assertNotNull(cyclicNumberAxis0);
XYPlot xYPlot0 = new XYPlot(xYDataset0, (ValueAxis) cyclicNumberAxis0, (ValueAxis) cyclicNumberAxis0, (XYItemRenderer) candlestickRenderer0);
assertNull(cyclicNumberAxis0.getLabelToolTip());
assertEquals(true, cyclicNumberAxis0.isAutoRange());
assertEquals(false, cyclicNumberAxis0.isVerticalTickLabels());
assertEquals(0.05, cyclicNumberAxis0.getUpperMargin(), 0.01D);
assertEquals((-3875.55), cyclicNumberAxis0.getOffset(), 0.01D);
assertEquals(0.0, cyclicNumberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(1.0E-8, cyclicNumberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(1.05, cyclicNumberAxis0.getPeriod(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isInverted());
assertEquals("", cyclicNumberAxis0.getLabel());
assertEquals(true, cyclicNumberAxis0.getAutoRangeStickyZero());
assertEquals(0.0, cyclicNumberAxis0.getLowerBound(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isBoundMappedToLastCycle());
assertEquals(2.0F, cyclicNumberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, cyclicNumberAxis0.getFixedDimension(), 0.01D);
assertNull(cyclicNumberAxis0.getLabelURL());
assertEquals(false, cyclicNumberAxis0.isNegativeArrowVisible());
assertEquals(true, cyclicNumberAxis0.isAdvanceLineVisible());
assertEquals(true, cyclicNumberAxis0.getAutoRangeIncludesZero());
assertEquals(true, cyclicNumberAxis0.isTickLabelsVisible());
assertEquals(true, cyclicNumberAxis0.isAutoTickUnitSelection());
assertEquals(0.0F, cyclicNumberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, cyclicNumberAxis0.isPositiveArrowVisible());
assertEquals(0.0, cyclicNumberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, cyclicNumberAxis0.getUpperBound(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAxisLineVisible());
assertEquals(0.05, cyclicNumberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isVisible());
assertEquals(true, cyclicNumberAxis0.isTickMarksVisible());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(Double.NaN, candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertFalse(double0 == double1);
assertFalse(double1 == double0);
assertNotNull(xYPlot0);
boolean boolean0 = candlestickRenderer0.hasListener((EventListener) xYPlot0);
assertNull(cyclicNumberAxis0.getLabelToolTip());
assertEquals(true, cyclicNumberAxis0.isAutoRange());
assertEquals(false, cyclicNumberAxis0.isVerticalTickLabels());
assertEquals(0.05, cyclicNumberAxis0.getUpperMargin(), 0.01D);
assertEquals((-3875.55), cyclicNumberAxis0.getOffset(), 0.01D);
assertEquals(0.0, cyclicNumberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(1.0E-8, cyclicNumberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(1.05, cyclicNumberAxis0.getPeriod(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isInverted());
assertEquals("", cyclicNumberAxis0.getLabel());
assertEquals(true, cyclicNumberAxis0.getAutoRangeStickyZero());
assertEquals(0.0, cyclicNumberAxis0.getLowerBound(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isBoundMappedToLastCycle());
assertEquals(2.0F, cyclicNumberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, cyclicNumberAxis0.getFixedDimension(), 0.01D);
assertNull(cyclicNumberAxis0.getLabelURL());
assertEquals(false, cyclicNumberAxis0.isNegativeArrowVisible());
assertEquals(true, cyclicNumberAxis0.isAdvanceLineVisible());
assertEquals(true, cyclicNumberAxis0.getAutoRangeIncludesZero());
assertEquals(true, cyclicNumberAxis0.isTickLabelsVisible());
assertEquals(true, cyclicNumberAxis0.isAutoTickUnitSelection());
assertEquals(0.0F, cyclicNumberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, cyclicNumberAxis0.isPositiveArrowVisible());
assertEquals(0.0, cyclicNumberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, cyclicNumberAxis0.getUpperBound(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAxisLineVisible());
assertEquals(0.05, cyclicNumberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isVisible());
assertEquals(true, cyclicNumberAxis0.isTickMarksVisible());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(Double.NaN, candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertFalse(double0 == double1);
assertFalse(double1 == double0);
assertTrue(boolean0);
}
@Test
public void test002() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
combinedDomainXYPlot0.setRangeAxis((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
DynamicTimeSeriesCollection dynamicTimeSeriesCollection0 = new DynamicTimeSeriesCollection(int0, int0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getOldestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getPosition());
// // Unstable assertion: assertEquals(-1, dynamicTimeSeriesCollection0.getNewestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dynamicTimeSeriesCollection0);
XYBarDataset xYBarDataset0 = new XYBarDataset((XYDataset) dynamicTimeSeriesCollection0, (double) int0);
// // Unstable assertion: assertEquals(0.0, xYBarDataset0.getBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getOldestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getPosition());
// // Unstable assertion: assertEquals(-1, dynamicTimeSeriesCollection0.getNewestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(xYBarDataset0);
XYDotRenderer xYDotRenderer0 = new XYDotRenderer();
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotHeight());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotWidth());
// // Unstable assertion: assertEquals(2.0, xYDotRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(3, xYDotRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertNotNull(xYDotRenderer0);
XYPlot xYPlot0 = new XYPlot((XYDataset) xYBarDataset0, (ValueAxis) dateAxis0, (ValueAxis) dateAxis0, (XYItemRenderer) xYDotRenderer0);
// // Unstable assertion: assertEquals(0.0, xYBarDataset0.getBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getOldestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getPosition());
// // Unstable assertion: assertEquals(-1, dynamicTimeSeriesCollection0.getNewestIndex());
// // Unstable assertion: assertEquals(0, dynamicTimeSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotHeight());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getDotWidth());
// // Unstable assertion: assertEquals(2.0, xYDotRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(3, xYDotRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(1, xYDotRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(true, xYDotRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNotNull(xYPlot0);
combinedDomainXYPlot0.clearRangeAxes();
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
}
@Test
public void test003() throws Throwable {
CombinedDomainCategoryPlot combinedDomainCategoryPlot0 = new CombinedDomainCategoryPlot();
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertNotNull(combinedDomainCategoryPlot0);
ValueAxis valueAxis0 = combinedDomainCategoryPlot0.getRangeAxis();
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertNull(valueAxis0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot(valueAxis0);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertNotNull(combinedRangeXYPlot0);
ChartRenderingInfo chartRenderingInfo0 = new ChartRenderingInfo();
assertNotNull(chartRenderingInfo0);
PlotRenderingInfo plotRenderingInfo0 = new PlotRenderingInfo(chartRenderingInfo0);
assertEquals(0, plotRenderingInfo0.getSubplotCount());
assertNotNull(plotRenderingInfo0);
Point2D.Double point2D_Double0 = new Point2D.Double();
assertEquals(0.0, point2D_Double0.y, 0.01D);
assertEquals(0.0, point2D_Double0.x, 0.01D);
assertNotNull(point2D_Double0);
combinedRangeXYPlot0.zoomRangeAxes(point2D_Double0.x, point2D_Double0.x, plotRenderingInfo0, (Point2D) point2D_Double0);
assertEquals(0, plotRenderingInfo0.getSubplotCount());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(0.0, point2D_Double0.y, 0.01D);
assertEquals(0.0, point2D_Double0.x, 0.01D);
}
@Test
public void test004() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedDomainXYPlot0);
int int0 = 0;
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedRangeXYPlot0);
NumberAxis numberAxis0 = (NumberAxis)combinedRangeXYPlot0.getRangeAxis(int0);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.isAutoRange());
assertNull(numberAxis0.getLabel());
assertEquals(true, numberAxis0.isVisible());
assertEquals(false, numberAxis0.isInverted());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertNotNull(numberAxis0);
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot((ValueAxis) numberAxis0);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.isAutoRange());
assertNull(numberAxis0.getLabel());
assertEquals(true, numberAxis0.isVisible());
assertEquals(false, numberAxis0.isInverted());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertNotNull(combinedRangeCategoryPlot0);
AxisSpace axisSpace0 = combinedRangeCategoryPlot0.getFixedDomainAxisSpace();
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.isAutoRange());
assertNull(numberAxis0.getLabel());
assertEquals(true, numberAxis0.isVisible());
assertEquals(false, numberAxis0.isInverted());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertNull(axisSpace0);
boolean boolean0 = false;
combinedDomainXYPlot0.setFixedRangeAxisSpace(axisSpace0, boolean0);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.isAutoRange());
assertNull(numberAxis0.getLabel());
assertEquals(true, numberAxis0.isVisible());
assertEquals(false, numberAxis0.isInverted());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
}
@Test
public void test005() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertNotNull(xYPlot0);
SystemColor systemColor0 = SystemColor.control;
assertEquals(1, systemColor0.getTransparency());
assertEquals(-4144960, systemColor0.getRGB());
assertEquals(192, systemColor0.getRed());
assertEquals(255, systemColor0.getAlpha());
assertEquals("java.awt.SystemColor[i=17]", systemColor0.toString());
assertEquals(192, systemColor0.getBlue());
assertEquals(192, systemColor0.getGreen());
assertNotNull(systemColor0);
xYPlot0.setRangeCrosshairPaint((Paint) systemColor0);
assertEquals(1, systemColor0.getTransparency());
assertEquals(-4144960, systemColor0.getRGB());
assertEquals(192, systemColor0.getRed());
assertEquals(255, systemColor0.getAlpha());
assertEquals("java.awt.SystemColor[i=17]", systemColor0.toString());
assertEquals(192, systemColor0.getBlue());
assertEquals(192, systemColor0.getGreen());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
}
@Test
public void test006() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(xYPlot0);
int int0 = 65535;
GroupedStackedBarRenderer groupedStackedBarRenderer0 = new GroupedStackedBarRenderer();
assertEquals(2, groupedStackedBarRenderer0.getPassCount());
assertEquals(false, groupedStackedBarRenderer0.getRenderAsPercentages());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0, groupedStackedBarRenderer0.getRowCount());
assertEquals(true, groupedStackedBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, groupedStackedBarRenderer0.getBaseSeriesVisible());
assertEquals(0.2, groupedStackedBarRenderer0.getItemMargin(), 0.01D);
assertEquals(false, groupedStackedBarRenderer0.getBaseItemLabelsVisible());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.0, groupedStackedBarRenderer0.getBase(), 0.01D);
assertEquals(true, groupedStackedBarRenderer0.getBaseCreateEntities());
assertEquals(true, groupedStackedBarRenderer0.getIncludeBaseInRange());
assertEquals(2.0, groupedStackedBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(0.0, groupedStackedBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, groupedStackedBarRenderer0.isDrawBarOutline());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0.0, groupedStackedBarRenderer0.getUpperClip(), 0.01D);
assertEquals(true, groupedStackedBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, groupedStackedBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(1.0, groupedStackedBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(0.0, groupedStackedBarRenderer0.getLowerClip(), 0.01D);
assertEquals(0, groupedStackedBarRenderer0.getColumnCount());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertNotNull(groupedStackedBarRenderer0);
BasicStroke basicStroke0 = (BasicStroke)groupedStackedBarRenderer0.lookupSeriesStroke(int0);
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(2, basicStroke0.getEndCap());
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2, groupedStackedBarRenderer0.getPassCount());
assertEquals(false, groupedStackedBarRenderer0.getRenderAsPercentages());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0, groupedStackedBarRenderer0.getRowCount());
assertEquals(true, groupedStackedBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, groupedStackedBarRenderer0.getBaseSeriesVisible());
assertEquals(0.2, groupedStackedBarRenderer0.getItemMargin(), 0.01D);
assertEquals(false, groupedStackedBarRenderer0.getBaseItemLabelsVisible());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.0, groupedStackedBarRenderer0.getBase(), 0.01D);
assertEquals(true, groupedStackedBarRenderer0.getBaseCreateEntities());
assertEquals(true, groupedStackedBarRenderer0.getIncludeBaseInRange());
assertEquals(2.0, groupedStackedBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(0.0, groupedStackedBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, groupedStackedBarRenderer0.isDrawBarOutline());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0.0, groupedStackedBarRenderer0.getUpperClip(), 0.01D);
assertEquals(true, groupedStackedBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, groupedStackedBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(1.0, groupedStackedBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(0.0, groupedStackedBarRenderer0.getLowerClip(), 0.01D);
assertEquals(0, groupedStackedBarRenderer0.getColumnCount());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertNotNull(basicStroke0);
xYPlot0.setRangeCrosshairStroke((Stroke) basicStroke0);
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(2, basicStroke0.getEndCap());
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(2, groupedStackedBarRenderer0.getPassCount());
assertEquals(false, groupedStackedBarRenderer0.getRenderAsPercentages());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0, groupedStackedBarRenderer0.getRowCount());
assertEquals(true, groupedStackedBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, groupedStackedBarRenderer0.getBaseSeriesVisible());
assertEquals(0.2, groupedStackedBarRenderer0.getItemMargin(), 0.01D);
assertEquals(false, groupedStackedBarRenderer0.getBaseItemLabelsVisible());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.0, groupedStackedBarRenderer0.getBase(), 0.01D);
assertEquals(true, groupedStackedBarRenderer0.getBaseCreateEntities());
assertEquals(true, groupedStackedBarRenderer0.getIncludeBaseInRange());
assertEquals(2.0, groupedStackedBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(0.0, groupedStackedBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, groupedStackedBarRenderer0.isDrawBarOutline());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0.0, groupedStackedBarRenderer0.getUpperClip(), 0.01D);
assertEquals(true, groupedStackedBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, groupedStackedBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(1.0, groupedStackedBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(0.0, groupedStackedBarRenderer0.getLowerClip(), 0.01D);
assertEquals(0, groupedStackedBarRenderer0.getColumnCount());
assertEquals(false, groupedStackedBarRenderer0.getAutoPopulateSeriesOutlineStroke());
}
@Test
public void test007() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = true;
combinedDomainXYPlot0.setRangeCrosshairLockedOnData(boolean0);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
}
@Test
public void test008() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
ValueAxis valueAxis0 = combinedRangeXYPlot0.getDomainAxisForDataset(int0);
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(valueAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot(valueAxis0);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
Rectangle2D.Double rectangle2D_Double0 = (Rectangle2D.Double)Plot.DEFAULT_LEGEND_ITEM_BOX;
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertNotNull(rectangle2D_Double0);
boolean boolean0 = rectangle2D_Double0.isEmpty();
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertTrue(boolean0);
combinedDomainXYPlot0.setRangeCrosshairVisible(boolean0);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
}
@Test
public void test009() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = false;
combinedDomainXYPlot0.setRangeCrosshairVisible(boolean0);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
}
@Test
public void test010() throws Throwable {
double double0 = (-3875.55);
double double1 = Line2D.ptLineDistSq(double0, double0, double0, double0, double0, double0);
assertFalse(double0 == double1);
assertFalse(double1 == double0);
assertEquals(Double.NaN, double1, 0.01D);
int int0 = 243;
CandlestickRenderer candlestickRenderer0 = new CandlestickRenderer(double1);
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(Double.NaN, candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertFalse(double0 == double1);
assertFalse(double1 == double0);
assertNotNull(candlestickRenderer0);
XYDataset xYDataset0 = null;
String string0 = "";
CyclicNumberAxis cyclicNumberAxis0 = new CyclicNumberAxis(double0, string0);
assertEquals(0.05, cyclicNumberAxis0.getLowerMargin(), 0.01D);
assertEquals("", cyclicNumberAxis0.getLabel());
assertEquals(true, cyclicNumberAxis0.getAutoRangeIncludesZero());
assertEquals(true, cyclicNumberAxis0.getAutoRangeStickyZero());
assertEquals(true, cyclicNumberAxis0.isVisible());
assertEquals(false, cyclicNumberAxis0.isNegativeArrowVisible());
assertEquals((-3875.55), cyclicNumberAxis0.getOffset(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAdvanceLineVisible());
assertEquals(0.0, cyclicNumberAxis0.getFixedDimension(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isBoundMappedToLastCycle());
assertEquals(0.0, cyclicNumberAxis0.getFixedAutoRange(), 0.01D);
assertNull(cyclicNumberAxis0.getLabelToolTip());
assertEquals(true, cyclicNumberAxis0.isTickLabelsVisible());
assertEquals(0.0, cyclicNumberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, cyclicNumberAxis0.getPeriod(), 0.01D);
assertNull(cyclicNumberAxis0.getLabelURL());
assertEquals(1.0E-8, cyclicNumberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, cyclicNumberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, cyclicNumberAxis0.getLowerBound(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isTickMarksVisible());
assertEquals(false, cyclicNumberAxis0.isInverted());
assertEquals(false, cyclicNumberAxis0.isVerticalTickLabels());
assertEquals(true, cyclicNumberAxis0.isAxisLineVisible());
assertEquals(0.05, cyclicNumberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAutoRange());
assertEquals(0.0F, cyclicNumberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, cyclicNumberAxis0.isPositiveArrowVisible());
assertEquals(1.0, cyclicNumberAxis0.getUpperBound(), 0.01D);
assertFalse(double0 == double1);
assertNotNull(cyclicNumberAxis0);
XYPlot xYPlot0 = new XYPlot(xYDataset0, (ValueAxis) cyclicNumberAxis0, (ValueAxis) cyclicNumberAxis0, (XYItemRenderer) candlestickRenderer0);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.05, cyclicNumberAxis0.getLowerMargin(), 0.01D);
assertEquals(1.05, cyclicNumberAxis0.getUpperBound(), 0.01D);
assertEquals("", cyclicNumberAxis0.getLabel());
assertEquals(true, cyclicNumberAxis0.getAutoRangeIncludesZero());
assertEquals(true, cyclicNumberAxis0.getAutoRangeStickyZero());
assertEquals(true, cyclicNumberAxis0.isVisible());
assertEquals(false, cyclicNumberAxis0.isNegativeArrowVisible());
assertEquals((-3875.55), cyclicNumberAxis0.getOffset(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAdvanceLineVisible());
assertEquals(0.0, cyclicNumberAxis0.getFixedDimension(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isBoundMappedToLastCycle());
assertEquals(0.0, cyclicNumberAxis0.getFixedAutoRange(), 0.01D);
assertNull(cyclicNumberAxis0.getLabelToolTip());
assertEquals(true, cyclicNumberAxis0.isTickLabelsVisible());
assertEquals(0.0, cyclicNumberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAutoTickUnitSelection());
assertNull(cyclicNumberAxis0.getLabelURL());
assertEquals(1.0E-8, cyclicNumberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, cyclicNumberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, cyclicNumberAxis0.getLowerBound(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isTickMarksVisible());
assertEquals(1.05, cyclicNumberAxis0.getPeriod(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isInverted());
assertEquals(false, cyclicNumberAxis0.isVerticalTickLabels());
assertEquals(true, cyclicNumberAxis0.isAxisLineVisible());
assertEquals(0.05, cyclicNumberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAutoRange());
assertEquals(0.0F, cyclicNumberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, cyclicNumberAxis0.isPositiveArrowVisible());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(Double.NaN, candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertFalse(double0 == double1);
assertFalse(double1 == double0);
assertNotNull(xYPlot0);
Color color0 = Color.getColor(string0, int0);
assertEquals(0, color0.getGreen());
assertEquals(1, color0.getTransparency());
assertEquals("java.awt.Color[r=0,g=0,b=243]", color0.toString());
assertEquals(0, color0.getRed());
assertEquals(243, color0.getBlue());
assertEquals(-16776973, color0.getRGB());
assertEquals(255, color0.getAlpha());
assertNotNull(color0);
xYPlot0.setDomainCrosshairPaint((Paint) color0);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.05, cyclicNumberAxis0.getLowerMargin(), 0.01D);
assertEquals(1.05, cyclicNumberAxis0.getUpperBound(), 0.01D);
assertEquals("", cyclicNumberAxis0.getLabel());
assertEquals(true, cyclicNumberAxis0.getAutoRangeIncludesZero());
assertEquals(true, cyclicNumberAxis0.getAutoRangeStickyZero());
assertEquals(true, cyclicNumberAxis0.isVisible());
assertEquals(false, cyclicNumberAxis0.isNegativeArrowVisible());
assertEquals((-3875.55), cyclicNumberAxis0.getOffset(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAdvanceLineVisible());
assertEquals(0.0, cyclicNumberAxis0.getFixedDimension(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isBoundMappedToLastCycle());
assertEquals(0.0, cyclicNumberAxis0.getFixedAutoRange(), 0.01D);
assertNull(cyclicNumberAxis0.getLabelToolTip());
assertEquals(true, cyclicNumberAxis0.isTickLabelsVisible());
assertEquals(0.0, cyclicNumberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAutoTickUnitSelection());
assertNull(cyclicNumberAxis0.getLabelURL());
assertEquals(1.0E-8, cyclicNumberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, cyclicNumberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, cyclicNumberAxis0.getLowerBound(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isTickMarksVisible());
assertEquals(1.05, cyclicNumberAxis0.getPeriod(), 0.01D);
assertEquals(false, cyclicNumberAxis0.isInverted());
assertEquals(false, cyclicNumberAxis0.isVerticalTickLabels());
assertEquals(true, cyclicNumberAxis0.isAxisLineVisible());
assertEquals(0.05, cyclicNumberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, cyclicNumberAxis0.isAutoRange());
assertEquals(0.0F, cyclicNumberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, cyclicNumberAxis0.isPositiveArrowVisible());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(Double.NaN, candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertEquals(0, color0.getGreen());
assertEquals(1, color0.getTransparency());
assertEquals("java.awt.Color[r=0,g=0,b=243]", color0.toString());
assertEquals(0, color0.getRed());
assertEquals(243, color0.getBlue());
assertEquals(-16776973, color0.getRGB());
assertEquals(255, color0.getAlpha());
assertFalse(double0 == double1);
assertFalse(double1 == double0);
}
@Test
public void test011() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertNotNull(combinedRangeXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)Axis.DEFAULT_AXIS_LINE_STROKE;
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertNotNull(basicStroke0);
combinedRangeXYPlot0.setDomainCrosshairStroke((Stroke) basicStroke0);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
}
@Test
public void test012() throws Throwable {
NumberAxis3D numberAxis3D0 = new NumberAxis3D();
assertNull(numberAxis3D0.getLabelURL());
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertNull(numberAxis3D0.getLabel());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(1.0, numberAxis3D0.getUpperBound(), 0.01D);
assertNotNull(numberAxis3D0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot((ValueAxis) numberAxis3D0);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertNull(numberAxis3D0.getLabel());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
boolean boolean0 = false;
combinedRangeXYPlot0.setDomainCrosshairLockedOnData(boolean0);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertNull(numberAxis3D0.getLabel());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
}
@Test
public void test013() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = true;
combinedDomainXYPlot0.setDomainCrosshairLockedOnData(boolean0);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
}
@Test
public void test014() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNotNull(combinedRangeXYPlot0);
boolean boolean0 = true;
combinedRangeXYPlot0.setDomainCrosshairVisible(boolean0);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
}
@Test
public void test015() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertNotNull(xYPlot0);
boolean boolean0 = false;
xYPlot0.setDomainCrosshairVisible(boolean0);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
}
@Test
public void test016() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNotNull(xYPlot0);
int int0 = 30;
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot();
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedRangeCategoryPlot0);
NumberAxis numberAxis0 = (NumberAxis)combinedRangeCategoryPlot0.getRangeAxisForDataset(int0);
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelToolTip());
assertNull(numberAxis0.getLabelURL());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertNull(numberAxis0.getLabel());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(numberAxis0);
boolean boolean0 = false;
xYPlot0.setDomainAxis(int0, (ValueAxis) numberAxis0, boolean0);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelToolTip());
assertNull(numberAxis0.getLabelURL());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertNull(numberAxis0.getLabel());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
}
@Test
public void test017() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertNotNull(xYPlot0);
String string0 = "Null 'order' argument.";
JFreeChart jFreeChart0 = new JFreeChart(string0, (Plot) xYPlot0);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, jFreeChart0.getSubtitleCount());
assertEquals(15, jFreeChart0.getBackgroundImageAlignment());
assertEquals(true, jFreeChart0.getAntiAlias());
assertEquals(false, jFreeChart0.isBorderVisible());
assertEquals(true, jFreeChart0.isNotify());
assertEquals(0.5F, jFreeChart0.getBackgroundImageAlpha(), 0.01F);
assertNotNull(jFreeChart0);
int int0 = 43;
BufferedImage bufferedImage0 = jFreeChart0.createBufferedImage(int0, int0);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0, bufferedImage0.getMinY());
assertEquals(1, bufferedImage0.getNumYTiles());
assertEquals(43, bufferedImage0.getHeight());
assertEquals(0, bufferedImage0.getTileGridXOffset());
assertEquals(0, bufferedImage0.getMinX());
assertEquals(0, bufferedImage0.getTileGridYOffset());
assertEquals(3, bufferedImage0.getTransparency());
assertEquals(true, bufferedImage0.hasTileWriters());
assertEquals(43, bufferedImage0.getWidth());
assertEquals(0, bufferedImage0.getMinTileY());
assertEquals(0, bufferedImage0.getMinTileX());
assertEquals(43, bufferedImage0.getTileHeight());
assertEquals(2, bufferedImage0.getType());
assertEquals(1, bufferedImage0.getNumXTiles());
assertEquals(false, bufferedImage0.isAlphaPremultiplied());
assertEquals(0.5F, bufferedImage0.getAccelerationPriority(), 0.01F);
assertEquals(43, bufferedImage0.getTileWidth());
assertEquals(1, jFreeChart0.getSubtitleCount());
assertEquals(15, jFreeChart0.getBackgroundImageAlignment());
assertEquals(true, jFreeChart0.getAntiAlias());
assertEquals(false, jFreeChart0.isBorderVisible());
assertEquals(true, jFreeChart0.isNotify());
assertEquals(0.5F, jFreeChart0.getBackgroundImageAlpha(), 0.01F);
assertNotNull(bufferedImage0);
SunGraphics2D sunGraphics2D0 = (SunGraphics2D)bufferedImage0.createGraphics();
assertEquals("sun.java2d.SunGraphics2D[font=java.awt.Font[family=Dialog,name=Dialog,style=plain,size=12],color=java.awt.Color[r=255,g=255,b=255]]", sunGraphics2D0.toString());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0, bufferedImage0.getMinY());
assertEquals(1, bufferedImage0.getNumYTiles());
assertEquals(43, bufferedImage0.getHeight());
assertEquals(0, bufferedImage0.getTileGridXOffset());
assertEquals(0, bufferedImage0.getMinX());
assertEquals(0, bufferedImage0.getTileGridYOffset());
assertEquals(3, bufferedImage0.getTransparency());
assertEquals(true, bufferedImage0.hasTileWriters());
assertEquals(43, bufferedImage0.getWidth());
assertEquals(0, bufferedImage0.getMinTileY());
assertEquals(0, bufferedImage0.getMinTileX());
assertEquals(43, bufferedImage0.getTileHeight());
assertEquals(2, bufferedImage0.getType());
assertEquals(1, bufferedImage0.getNumXTiles());
assertEquals(false, bufferedImage0.isAlphaPremultiplied());
assertEquals(0.5F, bufferedImage0.getAccelerationPriority(), 0.01F);
assertEquals(43, bufferedImage0.getTileWidth());
assertEquals(1, jFreeChart0.getSubtitleCount());
assertEquals(15, jFreeChart0.getBackgroundImageAlignment());
assertEquals(true, jFreeChart0.getAntiAlias());
assertEquals(false, jFreeChart0.isBorderVisible());
assertEquals(true, jFreeChart0.isNotify());
assertEquals(0.5F, jFreeChart0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, sunGraphics2D0.antialiasHint);
assertEquals(0, sunGraphics2D0.constrainX);
assertEquals((-1), sunGraphics2D0.pixel);
assertEquals(0, sunGraphics2D0.textAntialiasHint);
assertEquals(0, sunGraphics2D0.strokeHint);
assertEquals(0, sunGraphics2D0.transformState);
assertEquals(0, sunGraphics2D0.transX);
assertEquals((-1), sunGraphics2D0.eargb);
assertEquals(0, sunGraphics2D0.transY);
assertEquals(1, sunGraphics2D0.interpolationType);
assertEquals(0, sunGraphics2D0.paintState);
assertEquals(0, sunGraphics2D0.strokeState);
assertEquals(0, sunGraphics2D0.constrainY);
assertEquals(0, sunGraphics2D0.clipState);
assertEquals(0, sunGraphics2D0.compositeState);
assertEquals(0, sunGraphics2D0.renderHint);
assertEquals(140, sunGraphics2D0.lcdTextContrast);
assertNotNull(sunGraphics2D0);
DefaultTreeCellRenderer defaultTreeCellRenderer0 = new DefaultTreeCellRenderer();
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertNotNull(defaultTreeCellRenderer0);
ImageIconUIResource imageIconUIResource0 = (ImageIconUIResource)defaultTreeCellRenderer0.getLeafIcon();
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertNotNull(imageIconUIResource0);
JButton jButton0 = new JButton(string0, (Icon) imageIconUIResource0);
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(false, jButton0.isMaximumSizeSet());
assertEquals(false, jButton0.isFocusTraversalPolicySet());
assertEquals(false, jButton0.isCursorSet());
assertEquals(true, jButton0.isVisible());
assertEquals(false, jButton0.isPreferredSizeSet());
assertEquals(true, jButton0.isFontSet());
assertEquals(false, jButton0.isFocusTraversalPolicyProvider());
assertEquals(0, jButton0.getComponentCount());
assertEquals(false, jButton0.isDisplayable());
assertEquals(false, jButton0.isLightweight());
assertEquals(false, jButton0.isMinimumSizeSet());
assertEquals(true, jButton0.isEnabled());
assertEquals(true, jButton0.isBackgroundSet());
assertEquals(false, jButton0.isShowing());
assertEquals(true, jButton0.getFocusTraversalKeysEnabled());
assertEquals(true, jButton0.isForegroundSet());
assertEquals(false, jButton0.getIgnoreRepaint());
assertEquals(0, jButton0.countComponents());
assertEquals(false, jButton0.isValid());
assertEquals(false, jButton0.isFocusCycleRoot());
assertNotNull(jButton0);
Rectangle rectangle0 = jButton0.getBounds();
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(true, rectangle0.isEmpty());
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(false, jButton0.isMaximumSizeSet());
assertEquals(false, jButton0.isFocusTraversalPolicySet());
assertEquals(false, jButton0.isCursorSet());
assertEquals(true, jButton0.isVisible());
assertEquals(false, jButton0.isPreferredSizeSet());
assertEquals(true, jButton0.isFontSet());
assertEquals(false, jButton0.isFocusTraversalPolicyProvider());
assertEquals(0, jButton0.getComponentCount());
assertEquals(false, jButton0.isDisplayable());
assertEquals(false, jButton0.isLightweight());
assertEquals(false, jButton0.isMinimumSizeSet());
assertEquals(true, jButton0.isEnabled());
assertEquals(true, jButton0.isBackgroundSet());
assertEquals(false, jButton0.isShowing());
assertEquals(true, jButton0.getFocusTraversalKeysEnabled());
assertEquals(true, jButton0.isForegroundSet());
assertEquals(false, jButton0.getIgnoreRepaint());
assertEquals(0, jButton0.countComponents());
assertEquals(false, jButton0.isValid());
assertEquals(false, jButton0.isFocusCycleRoot());
assertEquals(0, rectangle0.y);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.height);
assertEquals(0, rectangle0.width);
assertNotNull(rectangle0);
LineRenderer3D lineRenderer3D0 = new LineRenderer3D();
assertEquals(false, lineRenderer3D0.getUseFillPaint());
assertEquals(0.0, lineRenderer3D0.getItemMargin(), 0.01D);
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0, lineRenderer3D0.getColumnCount());
assertEquals(8.0, lineRenderer3D0.getYOffset(), 0.01D);
assertEquals(2.0, lineRenderer3D0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, lineRenderer3D0.getBaseCreateEntities());
assertEquals(true, lineRenderer3D0.getBaseLinesVisible());
assertEquals(false, lineRenderer3D0.getUseSeriesOffset());
assertEquals(true, lineRenderer3D0.getAutoPopulateSeriesPaint());
assertEquals(false, lineRenderer3D0.getBaseItemLabelsVisible());
assertEquals(true, lineRenderer3D0.getBaseSeriesVisibleInLegend());
assertEquals(false, lineRenderer3D0.getUseOutlinePaint());
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesFillPaint());
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesStroke());
assertEquals(2, lineRenderer3D0.getPassCount());
assertEquals(false, lineRenderer3D0.getBaseShapesVisible());
assertEquals(true, lineRenderer3D0.getBaseSeriesVisible());
assertEquals(true, lineRenderer3D0.getBaseShapesFilled());
assertEquals(true, lineRenderer3D0.getDrawOutlines());
assertEquals(12.0, lineRenderer3D0.getXOffset(), 0.01D);
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0, lineRenderer3D0.getRowCount());
assertEquals(true, lineRenderer3D0.getAutoPopulateSeriesShape());
assertNotNull(lineRenderer3D0);
BasicStroke basicStroke0 = (BasicStroke)lineRenderer3D0.getBaseStroke();
assertEquals(false, lineRenderer3D0.getUseFillPaint());
assertEquals(0.0, lineRenderer3D0.getItemMargin(), 0.01D);
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0, lineRenderer3D0.getColumnCount());
assertEquals(8.0, lineRenderer3D0.getYOffset(), 0.01D);
assertEquals(2.0, lineRenderer3D0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, lineRenderer3D0.getBaseCreateEntities());
assertEquals(true, lineRenderer3D0.getBaseLinesVisible());
assertEquals(false, lineRenderer3D0.getUseSeriesOffset());
assertEquals(true, lineRenderer3D0.getAutoPopulateSeriesPaint());
assertEquals(false, lineRenderer3D0.getBaseItemLabelsVisible());
assertEquals(true, lineRenderer3D0.getBaseSeriesVisibleInLegend());
assertEquals(false, lineRenderer3D0.getUseOutlinePaint());
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesFillPaint());
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesStroke());
assertEquals(2, lineRenderer3D0.getPassCount());
assertEquals(false, lineRenderer3D0.getBaseShapesVisible());
assertEquals(true, lineRenderer3D0.getBaseSeriesVisible());
assertEquals(true, lineRenderer3D0.getBaseShapesFilled());
assertEquals(true, lineRenderer3D0.getDrawOutlines());
assertEquals(12.0, lineRenderer3D0.getXOffset(), 0.01D);
assertEquals(false, lineRenderer3D0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0, lineRenderer3D0.getRowCount());
assertEquals(true, lineRenderer3D0.getAutoPopulateSeriesShape());
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2, basicStroke0.getEndCap());
assertNotNull(basicStroke0);
CandlestickRenderer candlestickRenderer0 = new CandlestickRenderer();
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals((-1.0), candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertNotNull(candlestickRenderer0);
Color color0 = (Color)candlestickRenderer0.getDownPaint();
assertEquals(1, candlestickRenderer0.getPassCount());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesShape());
assertEquals(3, candlestickRenderer0.getDefaultEntityRadius());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, candlestickRenderer0.getAutoPopulateSeriesPaint());
assertEquals(2.0, candlestickRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, candlestickRenderer0.getBaseSeriesVisible());
assertEquals(7.2E7, candlestickRenderer0.getMaxCandleWidthInMilliseconds(), 0.01D);
assertEquals(0, candlestickRenderer0.getAutoWidthMethod());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesStroke());
assertEquals(0.6428571428571429, candlestickRenderer0.getAutoWidthFactor(), 0.01D);
assertEquals(true, candlestickRenderer0.getDrawVolume());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, candlestickRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, candlestickRenderer0.getUseOutlinePaint());
assertEquals(0.0, candlestickRenderer0.getAutoWidthGap(), 0.01D);
assertEquals((-1.0), candlestickRenderer0.getCandleWidth(), 0.01D);
assertEquals(true, candlestickRenderer0.getBaseCreateEntities());
assertEquals(false, candlestickRenderer0.getBaseItemLabelsVisible());
assertEquals(0, color0.getGreen());
assertEquals(-65536, color0.getRGB());
assertEquals(1, color0.getTransparency());
assertEquals(255, color0.getAlpha());
assertEquals("java.awt.Color[r=255,g=0,b=0]", color0.toString());
assertEquals(0, color0.getBlue());
assertEquals(255, color0.getRed());
assertNotNull(color0);
// Undeclared exception!
try {
xYPlot0.drawVerticalLine(sunGraphics2D0, rectangle0, rectangle0.x, basicStroke0, color0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test
public void test018() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
Layer layer0 = null;
Collection collection0 = combinedDomainXYPlot0.getRangeMarkers(int0, layer0);
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertNull(collection0);
}
@Test
public void test019() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
Layer layer0 = Layer.BACKGROUND;
// // Unstable assertion: assertEquals("Layer.BACKGROUND", layer0.toString());
// // Unstable assertion: assertNotNull(layer0);
Collection collection0 = combinedDomainXYPlot0.getRangeMarkers(int0, layer0);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals("Layer.BACKGROUND", layer0.toString());
// // Unstable assertion: assertNull(collection0);
}
@Test
public void test020() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeZoomable());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertNotNull(xYPlot0);
Layer layer0 = null;
Collection collection0 = xYPlot0.getDomainMarkers(layer0);
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeZoomable());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertNull(collection0);
}
@Test
public void test021() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, xYPlot0.getWeight());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertNotNull(xYPlot0);
int int0 = 65535;
Layer layer0 = Layer.BACKGROUND;
assertEquals("Layer.BACKGROUND", layer0.toString());
assertNotNull(layer0);
Collection collection0 = xYPlot0.getDomainMarkers(int0, layer0);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, xYPlot0.getWeight());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals("Layer.BACKGROUND", layer0.toString());
assertNull(collection0);
}
@Test
public void test022() throws Throwable {
int int0 = 0;
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedRangeXYPlot0);
NumberAxis numberAxis0 = (NumberAxis)combinedRangeXYPlot0.getRangeAxisForDataset(int0);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isInverted());
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabel());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertNotNull(numberAxis0);
}
@Test
public void test023() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNotNull(combinedDomainXYPlot0);
int int0 = 2796;
// Undeclared exception!
try {
ValueAxis valueAxis0 = combinedDomainXYPlot0.getRangeAxisForDataset(int0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Index 2796 out of bounds.
//
}
}
@Test
public void test024() throws Throwable {
int int0 = (-934);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNotNull(combinedDomainXYPlot0);
// Undeclared exception!
try {
ValueAxis valueAxis0 = combinedDomainXYPlot0.getRangeAxisForDataset(int0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Index -934 out of bounds.
//
}
}
@Test
public void test025() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
int int0 = 32;
// Undeclared exception!
try {
ValueAxis valueAxis0 = combinedDomainXYPlot0.getDomainAxisForDataset(int0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Index 32 out of bounds.
//
}
}
@Test
public void test026() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNotNull(combinedRangeXYPlot0);
int int0 = (-1058);
// Undeclared exception!
try {
ValueAxis valueAxis0 = combinedRangeXYPlot0.getDomainAxisForDataset(int0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Index -1058 out of bounds.
//
}
}
@Test
public void test027() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertNotNull(combinedRangeXYPlot0);
Rectangle2D.Double rectangle2D_Double0 = (Rectangle2D.Double)Plot.DEFAULT_LEGEND_ITEM_BOX;
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertNotNull(rectangle2D_Double0);
Rectangle2D.Double rectangle2D_Double1 = (Rectangle2D.Double)rectangle2D_Double0.getFrame();
// // Unstable assertion: assertNotSame(rectangle2D_Double1, rectangle2D_Double0);
// // Unstable assertion: assertNotSame(rectangle2D_Double0, rectangle2D_Double1);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertTrue(rectangle2D_Double1.equals((Object)rectangle2D_Double0));
// // Unstable assertion: assertTrue(rectangle2D_Double0.equals((Object)rectangle2D_Double1));
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertNotNull(rectangle2D_Double1);
Graphics2D graphics2D0 = null;
DefaultKeyedValuesDataset defaultKeyedValuesDataset0 = new DefaultKeyedValuesDataset();
// // Unstable assertion: assertEquals(0, defaultKeyedValuesDataset0.getItemCount());
// // Unstable assertion: assertNotNull(defaultKeyedValuesDataset0);
List list0 = defaultKeyedValuesDataset0.getKeys();
// // Unstable assertion: assertEquals(0, list0.size());
// // Unstable assertion: assertEquals(true, list0.isEmpty());
// // Unstable assertion: assertEquals(0, defaultKeyedValuesDataset0.getItemCount());
// // Unstable assertion: assertNotNull(list0);
combinedRangeXYPlot0.drawDomainTickBands(graphics2D0, (Rectangle2D) rectangle2D_Double1, (List) list0);
// // Unstable assertion: assertNotSame(rectangle2D_Double1, rectangle2D_Double0);
// // Unstable assertion: assertNotSame(rectangle2D_Double0, rectangle2D_Double1);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(0, list0.size());
// // Unstable assertion: assertEquals(true, list0.isEmpty());
// // Unstable assertion: assertEquals(0, defaultKeyedValuesDataset0.getItemCount());
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertTrue(rectangle2D_Double1.equals((Object)rectangle2D_Double0));
// // Unstable assertion: assertTrue(rectangle2D_Double0.equals((Object)rectangle2D_Double1));
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
}
@Test
public void test028() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNotNull(combinedRangeXYPlot0);
int int0 = (-1058);
Graphics2D graphics2D0 = null;
EmptyBlock emptyBlock0 = new EmptyBlock((double) int0, (double) int0);
assertEquals(0.0, emptyBlock0.getContentYOffset(), 0.01D);
assertEquals((-1058.0), emptyBlock0.getHeight(), 0.01D);
assertNull(emptyBlock0.getID());
assertEquals(0.0, emptyBlock0.getContentXOffset(), 0.01D);
assertEquals((-1058.0), emptyBlock0.getWidth(), 0.01D);
assertNotNull(emptyBlock0);
Rectangle2D.Float rectangle2D_Float0 = (Rectangle2D.Float)emptyBlock0.getBounds();
assertEquals(0.0, rectangle2D_Float0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle2D_Float0.getMinY(), 0.01D);
assertEquals(0.0, rectangle2D_Float0.getMinX(), 0.01D);
assertEquals(0.0, rectangle2D_Float0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle2D_Float0.getMaxY(), 0.01D);
assertEquals(0.0, rectangle2D_Float0.getCenterX(), 0.01D);
assertEquals(0.0, emptyBlock0.getContentYOffset(), 0.01D);
assertEquals((-1058.0), emptyBlock0.getHeight(), 0.01D);
assertNull(emptyBlock0.getID());
assertEquals(0.0, emptyBlock0.getContentXOffset(), 0.01D);
assertEquals((-1058.0), emptyBlock0.getWidth(), 0.01D);
assertEquals(0.0F, rectangle2D_Float0.width, 0.01F);
assertEquals(0.0F, rectangle2D_Float0.x, 0.01F);
assertEquals(0.0F, rectangle2D_Float0.y, 0.01F);
assertEquals(0.0F, rectangle2D_Float0.height, 0.01F);
assertNotNull(rectangle2D_Float0);
AxisSpace axisSpace0 = combinedRangeXYPlot0.getFixedRangeAxisSpace();
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNull(axisSpace0);
// Undeclared exception!
try {
AxisSpace axisSpace1 = combinedRangeXYPlot0.calculateRangeAxisSpace(graphics2D0, rectangle2D_Float0, axisSpace0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test
public void test029() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
JPopupMenu.Separator jPopupMenu_Separator0 = new JPopupMenu.Separator();
assertEquals(false, jPopupMenu_Separator0.isMaximumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicySet());
assertEquals(0, jPopupMenu_Separator0.getComponentCount());
assertEquals(true, jPopupMenu_Separator0.isForegroundSet());
assertEquals(true, jPopupMenu_Separator0.getFocusTraversalKeysEnabled());
assertEquals(false, jPopupMenu_Separator0.isDisplayable());
assertEquals(true, jPopupMenu_Separator0.isVisible());
assertEquals(false, jPopupMenu_Separator0.isCursorSet());
assertEquals(false, jPopupMenu_Separator0.isValid());
assertEquals(0, jPopupMenu_Separator0.countComponents());
assertEquals(false, jPopupMenu_Separator0.getIgnoreRepaint());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicyProvider());
assertEquals(false, jPopupMenu_Separator0.isFontSet());
assertEquals(true, jPopupMenu_Separator0.isBackgroundSet());
assertEquals(false, jPopupMenu_Separator0.isMinimumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isLightweight());
assertEquals(true, jPopupMenu_Separator0.isEnabled());
assertEquals(false, jPopupMenu_Separator0.isPreferredSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusCycleRoot());
assertEquals(false, jPopupMenu_Separator0.isShowing());
assertNotNull(jPopupMenu_Separator0);
ColorUIResource colorUIResource0 = (ColorUIResource)jPopupMenu_Separator0.getBackground();
assertEquals(false, jPopupMenu_Separator0.isMaximumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicySet());
assertEquals(0, jPopupMenu_Separator0.getComponentCount());
assertEquals(true, jPopupMenu_Separator0.isForegroundSet());
assertEquals(true, jPopupMenu_Separator0.getFocusTraversalKeysEnabled());
assertEquals(false, jPopupMenu_Separator0.isDisplayable());
assertEquals(true, jPopupMenu_Separator0.isVisible());
assertEquals(false, jPopupMenu_Separator0.isCursorSet());
assertEquals(false, jPopupMenu_Separator0.isValid());
assertEquals(0, jPopupMenu_Separator0.countComponents());
assertEquals(false, jPopupMenu_Separator0.getIgnoreRepaint());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicyProvider());
assertEquals(false, jPopupMenu_Separator0.isFontSet());
assertEquals(true, jPopupMenu_Separator0.isBackgroundSet());
assertEquals(false, jPopupMenu_Separator0.isMinimumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isLightweight());
assertEquals(true, jPopupMenu_Separator0.isEnabled());
assertEquals(false, jPopupMenu_Separator0.isPreferredSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusCycleRoot());
assertEquals(false, jPopupMenu_Separator0.isShowing());
assertEquals(-1, colorUIResource0.getRGB());
assertEquals(255, colorUIResource0.getAlpha());
assertEquals(1, colorUIResource0.getTransparency());
assertEquals(255, colorUIResource0.getGreen());
assertEquals(255, colorUIResource0.getRed());
assertEquals("javax.swing.plaf.ColorUIResource[r=255,g=255,b=255]", colorUIResource0.toString());
assertEquals(255, colorUIResource0.getBlue());
assertNotNull(colorUIResource0);
PointerNeedle pointerNeedle0 = new PointerNeedle();
assertEquals(0.5, pointerNeedle0.getRotateY(), 0.01D);
assertEquals(0.5, pointerNeedle0.getRotateX(), 0.01D);
assertEquals(5, pointerNeedle0.getSize());
assertNotNull(pointerNeedle0);
BasicStroke basicStroke0 = (BasicStroke)pointerNeedle0.getOutlineStroke();
assertEquals(0.5, pointerNeedle0.getRotateY(), 0.01D);
assertEquals(0.5, pointerNeedle0.getRotateX(), 0.01D);
assertEquals(5, pointerNeedle0.getSize());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertNotNull(basicStroke0);
ValueMarker valueMarker0 = new ValueMarker((double) int0, (Paint) colorUIResource0, (Stroke) basicStroke0, (Paint) colorUIResource0, (Stroke) basicStroke0, (float) int0);
assertEquals(0.0, valueMarker0.getValue(), 0.01D);
assertNull(valueMarker0.getLabel());
assertEquals(0.0F, valueMarker0.getAlpha(), 0.01F);
assertEquals(0.5, pointerNeedle0.getRotateY(), 0.01D);
assertEquals(0.5, pointerNeedle0.getRotateX(), 0.01D);
assertEquals(5, pointerNeedle0.getSize());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(false, jPopupMenu_Separator0.isMaximumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicySet());
assertEquals(0, jPopupMenu_Separator0.getComponentCount());
assertEquals(true, jPopupMenu_Separator0.isForegroundSet());
assertEquals(true, jPopupMenu_Separator0.getFocusTraversalKeysEnabled());
assertEquals(false, jPopupMenu_Separator0.isDisplayable());
assertEquals(true, jPopupMenu_Separator0.isVisible());
assertEquals(false, jPopupMenu_Separator0.isCursorSet());
assertEquals(false, jPopupMenu_Separator0.isValid());
assertEquals(0, jPopupMenu_Separator0.countComponents());
assertEquals(false, jPopupMenu_Separator0.getIgnoreRepaint());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicyProvider());
assertEquals(false, jPopupMenu_Separator0.isFontSet());
assertEquals(true, jPopupMenu_Separator0.isBackgroundSet());
assertEquals(false, jPopupMenu_Separator0.isMinimumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isLightweight());
assertEquals(true, jPopupMenu_Separator0.isEnabled());
assertEquals(false, jPopupMenu_Separator0.isPreferredSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusCycleRoot());
assertEquals(false, jPopupMenu_Separator0.isShowing());
assertEquals(-1, colorUIResource0.getRGB());
assertEquals(255, colorUIResource0.getAlpha());
assertEquals(1, colorUIResource0.getTransparency());
assertEquals(255, colorUIResource0.getGreen());
assertEquals(255, colorUIResource0.getRed());
assertEquals("javax.swing.plaf.ColorUIResource[r=255,g=255,b=255]", colorUIResource0.toString());
assertEquals(255, colorUIResource0.getBlue());
assertNotNull(valueMarker0);
Layer layer0 = Layer.FOREGROUND;
assertEquals("Layer.FOREGROUND", layer0.toString());
assertNotNull(layer0);
boolean boolean0 = false;
boolean boolean1 = combinedRangeXYPlot0.removeRangeMarker(int0, (Marker) valueMarker0, layer0, boolean0);
assertEquals("Layer.FOREGROUND", layer0.toString());
assertEquals(0.0, valueMarker0.getValue(), 0.01D);
assertNull(valueMarker0.getLabel());
assertEquals(0.0F, valueMarker0.getAlpha(), 0.01F);
assertEquals(0.5, pointerNeedle0.getRotateY(), 0.01D);
assertEquals(0.5, pointerNeedle0.getRotateX(), 0.01D);
assertEquals(5, pointerNeedle0.getSize());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(false, jPopupMenu_Separator0.isMaximumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicySet());
assertEquals(0, jPopupMenu_Separator0.getComponentCount());
assertEquals(true, jPopupMenu_Separator0.isForegroundSet());
assertEquals(true, jPopupMenu_Separator0.getFocusTraversalKeysEnabled());
assertEquals(false, jPopupMenu_Separator0.isDisplayable());
assertEquals(true, jPopupMenu_Separator0.isVisible());
assertEquals(false, jPopupMenu_Separator0.isCursorSet());
assertEquals(false, jPopupMenu_Separator0.isValid());
assertEquals(0, jPopupMenu_Separator0.countComponents());
assertEquals(false, jPopupMenu_Separator0.getIgnoreRepaint());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicyProvider());
assertEquals(false, jPopupMenu_Separator0.isFontSet());
assertEquals(true, jPopupMenu_Separator0.isBackgroundSet());
assertEquals(false, jPopupMenu_Separator0.isMinimumSizeSet());
assertEquals(false, jPopupMenu_Separator0.isLightweight());
assertEquals(true, jPopupMenu_Separator0.isEnabled());
assertEquals(false, jPopupMenu_Separator0.isPreferredSizeSet());
assertEquals(false, jPopupMenu_Separator0.isFocusCycleRoot());
assertEquals(false, jPopupMenu_Separator0.isShowing());
assertEquals(-1, colorUIResource0.getRGB());
assertEquals(255, colorUIResource0.getAlpha());
assertEquals(1, colorUIResource0.getTransparency());
assertEquals(255, colorUIResource0.getGreen());
assertEquals(255, colorUIResource0.getRed());
assertEquals("javax.swing.plaf.ColorUIResource[r=255,g=255,b=255]", colorUIResource0.toString());
assertEquals(255, colorUIResource0.getBlue());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertTrue(boolean1 == boolean0);
assertTrue(boolean0 == boolean1);
assertFalse(boolean1);
}
@Test
public void test030() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedDomainXYPlot0);
double double0 = 2353.3;
DefaultTreeCellRenderer defaultTreeCellRenderer0 = new DefaultTreeCellRenderer();
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertNotNull(defaultTreeCellRenderer0);
Point point0 = defaultTreeCellRenderer0.getLocation();
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(0.0, point0.getX(), 0.01D);
assertEquals(0.0, point0.getY(), 0.01D);
assertEquals("java.awt.Point[x=0,y=0]", point0.toString());
assertEquals(0, point0.y);
assertEquals(0, point0.x);
assertNotNull(point0);
Line2D.Double line2D_Double0 = new Line2D.Double();
assertEquals(0.0, line2D_Double0.x2, 0.01D);
assertEquals(0.0, line2D_Double0.x1, 0.01D);
assertEquals(0.0, line2D_Double0.y1, 0.01D);
assertEquals(0.0, line2D_Double0.y2, 0.01D);
assertNotNull(line2D_Double0);
boolean boolean0 = line2D_Double0.intersects(line2D_Double0.y2, (double) point0.y, (double) point0.y, double0);
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(0.0, point0.getX(), 0.01D);
assertEquals(0.0, point0.getY(), 0.01D);
assertEquals("java.awt.Point[x=0,y=0]", point0.toString());
assertEquals(0, point0.y);
assertEquals(0, point0.x);
assertEquals(0.0, line2D_Double0.x2, 0.01D);
assertEquals(0.0, line2D_Double0.x1, 0.01D);
assertEquals(0.0, line2D_Double0.y1, 0.01D);
assertEquals(0.0, line2D_Double0.y2, 0.01D);
assertFalse(boolean0);
Layer layer0 = Layer.FOREGROUND;
assertEquals("Layer.FOREGROUND", layer0.toString());
assertNotNull(layer0);
Marker marker0 = null;
// Undeclared exception!
try {
boolean boolean1 = combinedDomainXYPlot0.removeRangeMarker(point0.x, marker0, layer0, boolean0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Null 'marker' argument.
//
}
}
@Test
public void test031() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
combinedRangeXYPlot0.clearRangeMarkers(int0);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
}
@Test
public void test032() throws Throwable {
double double0 = 1341.74132860581;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNotNull(combinedDomainXYPlot0);
int int0 = combinedDomainXYPlot0.getBackgroundImageAlignment();
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, int0);
ValueMarker valueMarker0 = new ValueMarker(double0);
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertNull(valueMarker0.getLabel());
assertEquals(1341.74132860581, valueMarker0.getValue(), 0.01D);
assertNotNull(valueMarker0);
Layer layer0 = null;
combinedDomainXYPlot0.addRangeMarker(int0, (Marker) valueMarker0, layer0);
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertNull(valueMarker0.getLabel());
assertEquals(1341.74132860581, valueMarker0.getValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
}
@Test
public void test033() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
combinedRangeXYPlot0.clearRangeMarkers();
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
}
@Test
public void test034() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertNotNull(combinedDomainXYPlot0);
double double0 = 1240.29;
ValueMarker valueMarker0 = new ValueMarker(double0);
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertEquals(1240.29, valueMarker0.getValue(), 0.01D);
assertNull(valueMarker0.getLabel());
assertNotNull(valueMarker0);
FastScatterPlot fastScatterPlot0 = new FastScatterPlot();
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertNotNull(fastScatterPlot0);
NumberAxis numberAxis0 = (NumberAxis)fastScatterPlot0.getRangeAxis();
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(false, numberAxis0.isInverted());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals("Y", numberAxis0.getLabel());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertNull(numberAxis0.getLabelURL());
assertNotNull(numberAxis0);
int int0 = combinedDomainXYPlot0.getDomainAxisIndex((ValueAxis) numberAxis0);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(false, numberAxis0.isInverted());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals("Y", numberAxis0.getLabel());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals((-1), int0);
boolean boolean0 = true;
Layer layer0 = Layer.BACKGROUND;
assertEquals("Layer.BACKGROUND", layer0.toString());
assertNotNull(layer0);
combinedDomainXYPlot0.addDomainMarker(int0, (Marker) valueMarker0, layer0, boolean0);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(false, numberAxis0.isInverted());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals("Y", numberAxis0.getLabel());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertEquals(1240.29, valueMarker0.getValue(), 0.01D);
assertNull(valueMarker0.getLabel());
assertEquals("Layer.BACKGROUND", layer0.toString());
}
@Test
public void test035() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
Marker marker0 = null;
Layer layer0 = Layer.BACKGROUND;
assertEquals("Layer.BACKGROUND", layer0.toString());
assertNotNull(layer0);
// Undeclared exception!
try {
combinedDomainXYPlot0.addDomainMarker(marker0, layer0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Null 'marker' not permitted.
//
}
}
@Test
public void test036() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
combinedDomainXYPlot0.clearDomainMarkers(int0);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
}
@Test
public void test037() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedDomainXYPlot0);
combinedDomainXYPlot0.clearDomainMarkers();
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
}
@Test
public void test038() throws Throwable {
StatisticalLineAndShapeRenderer statisticalLineAndShapeRenderer0 = new StatisticalLineAndShapeRenderer();
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesPaint());
assertEquals(2.0, statisticalLineAndShapeRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, statisticalLineAndShapeRenderer0.getBaseItemLabelsVisible());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseCreateEntities());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseShapesFilled());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseShapesVisible());
assertEquals(false, statisticalLineAndShapeRenderer0.getUseOutlinePaint());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseLinesVisible());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseSeriesVisible());
assertEquals(0, statisticalLineAndShapeRenderer0.getRowCount());
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0, statisticalLineAndShapeRenderer0.getColumnCount());
assertEquals(false, statisticalLineAndShapeRenderer0.getUseSeriesOffset());
assertEquals(true, statisticalLineAndShapeRenderer0.getDrawOutlines());
assertEquals(0.0, statisticalLineAndShapeRenderer0.getItemMargin(), 0.01D);
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(2, statisticalLineAndShapeRenderer0.getPassCount());
assertEquals(false, statisticalLineAndShapeRenderer0.getUseFillPaint());
assertEquals(true, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesShape());
assertNotNull(statisticalLineAndShapeRenderer0);
int int0 = (-25);
Color color0 = (Color)statisticalLineAndShapeRenderer0.lookupSeriesPaint(int0);
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesPaint());
assertEquals(2.0, statisticalLineAndShapeRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, statisticalLineAndShapeRenderer0.getBaseItemLabelsVisible());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseCreateEntities());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseShapesFilled());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseShapesVisible());
assertEquals(false, statisticalLineAndShapeRenderer0.getUseOutlinePaint());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseLinesVisible());
assertEquals(true, statisticalLineAndShapeRenderer0.getBaseSeriesVisible());
assertEquals(0, statisticalLineAndShapeRenderer0.getRowCount());
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0, statisticalLineAndShapeRenderer0.getColumnCount());
assertEquals(false, statisticalLineAndShapeRenderer0.getUseSeriesOffset());
assertEquals(true, statisticalLineAndShapeRenderer0.getDrawOutlines());
assertEquals(0.0, statisticalLineAndShapeRenderer0.getItemMargin(), 0.01D);
assertEquals(false, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(2, statisticalLineAndShapeRenderer0.getPassCount());
assertEquals(false, statisticalLineAndShapeRenderer0.getUseFillPaint());
assertEquals(true, statisticalLineAndShapeRenderer0.getAutoPopulateSeriesShape());
assertEquals(255, color0.getAlpha());
assertEquals(0, color0.getGreen());
assertEquals(0, color0.getRed());
assertEquals(-16776961, color0.getRGB());
assertEquals(1, color0.getTransparency());
assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
assertEquals(255, color0.getBlue());
assertNotNull(color0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertNotNull(combinedRangeXYPlot0);
int int1 = 453;
// Undeclared exception!
try {
combinedRangeXYPlot0.setQuadrantPaint(int1, (Paint) color0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The index value (453) should be in the range 0 to 3.
//
}
}
@Test
public void test039() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
Paint paint0 = combinedRangeXYPlot0.getQuadrantPaint(int0);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(paint0);
}
@Test
public void test040() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
int int0 = 273;
// Undeclared exception!
try {
Paint paint0 = combinedDomainXYPlot0.getQuadrantPaint(int0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// The index value (273) should be in the range 0 to 3.
//
}
}
@Test
public void test041() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNotNull(combinedRangeXYPlot0);
JPopupMenu.Separator jPopupMenu_Separator0 = new JPopupMenu.Separator();
assertEquals(false, jPopupMenu_Separator0.isMaximumSizeSet());
assertEquals(true, jPopupMenu_Separator0.isEnabled());
assertEquals(0, jPopupMenu_Separator0.getComponentCount());
assertEquals(true, jPopupMenu_Separator0.isVisible());
assertEquals(false, jPopupMenu_Separator0.isLightweight());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicyProvider());
assertEquals(false, jPopupMenu_Separator0.isFontSet());
assertEquals(false, jPopupMenu_Separator0.isCursorSet());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicySet());
assertEquals(false, jPopupMenu_Separator0.isShowing());
assertEquals(false, jPopupMenu_Separator0.isFocusCycleRoot());
assertEquals(false, jPopupMenu_Separator0.getIgnoreRepaint());
assertEquals(false, jPopupMenu_Separator0.isValid());
assertEquals(true, jPopupMenu_Separator0.isBackgroundSet());
assertEquals(false, jPopupMenu_Separator0.isPreferredSizeSet());
assertEquals(0, jPopupMenu_Separator0.countComponents());
assertEquals(true, jPopupMenu_Separator0.isForegroundSet());
assertEquals(true, jPopupMenu_Separator0.getFocusTraversalKeysEnabled());
assertEquals(false, jPopupMenu_Separator0.isDisplayable());
assertEquals(false, jPopupMenu_Separator0.isMinimumSizeSet());
assertNotNull(jPopupMenu_Separator0);
ColorUIResource colorUIResource0 = (ColorUIResource)jPopupMenu_Separator0.getBackground();
assertEquals(-1, colorUIResource0.getRGB());
assertEquals(1, colorUIResource0.getTransparency());
assertEquals(255, colorUIResource0.getBlue());
assertEquals(255, colorUIResource0.getAlpha());
assertEquals(255, colorUIResource0.getGreen());
assertEquals("javax.swing.plaf.ColorUIResource[r=255,g=255,b=255]", colorUIResource0.toString());
assertEquals(255, colorUIResource0.getRed());
assertEquals(false, jPopupMenu_Separator0.isMaximumSizeSet());
assertEquals(true, jPopupMenu_Separator0.isEnabled());
assertEquals(0, jPopupMenu_Separator0.getComponentCount());
assertEquals(true, jPopupMenu_Separator0.isVisible());
assertEquals(false, jPopupMenu_Separator0.isLightweight());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicyProvider());
assertEquals(false, jPopupMenu_Separator0.isFontSet());
assertEquals(false, jPopupMenu_Separator0.isCursorSet());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicySet());
assertEquals(false, jPopupMenu_Separator0.isShowing());
assertEquals(false, jPopupMenu_Separator0.isFocusCycleRoot());
assertEquals(false, jPopupMenu_Separator0.getIgnoreRepaint());
assertEquals(false, jPopupMenu_Separator0.isValid());
assertEquals(true, jPopupMenu_Separator0.isBackgroundSet());
assertEquals(false, jPopupMenu_Separator0.isPreferredSizeSet());
assertEquals(0, jPopupMenu_Separator0.countComponents());
assertEquals(true, jPopupMenu_Separator0.isForegroundSet());
assertEquals(true, jPopupMenu_Separator0.getFocusTraversalKeysEnabled());
assertEquals(false, jPopupMenu_Separator0.isDisplayable());
assertEquals(false, jPopupMenu_Separator0.isMinimumSizeSet());
assertNotNull(colorUIResource0);
combinedRangeXYPlot0.setRangeZeroBaselinePaint((Paint) colorUIResource0);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(-1, colorUIResource0.getRGB());
assertEquals(1, colorUIResource0.getTransparency());
assertEquals(255, colorUIResource0.getBlue());
assertEquals(255, colorUIResource0.getAlpha());
assertEquals(255, colorUIResource0.getGreen());
assertEquals("javax.swing.plaf.ColorUIResource[r=255,g=255,b=255]", colorUIResource0.toString());
assertEquals(255, colorUIResource0.getRed());
assertEquals(false, jPopupMenu_Separator0.isMaximumSizeSet());
assertEquals(true, jPopupMenu_Separator0.isEnabled());
assertEquals(0, jPopupMenu_Separator0.getComponentCount());
assertEquals(true, jPopupMenu_Separator0.isVisible());
assertEquals(false, jPopupMenu_Separator0.isLightweight());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicyProvider());
assertEquals(false, jPopupMenu_Separator0.isFontSet());
assertEquals(false, jPopupMenu_Separator0.isCursorSet());
assertEquals(false, jPopupMenu_Separator0.isFocusTraversalPolicySet());
assertEquals(false, jPopupMenu_Separator0.isShowing());
assertEquals(false, jPopupMenu_Separator0.isFocusCycleRoot());
assertEquals(false, jPopupMenu_Separator0.getIgnoreRepaint());
assertEquals(false, jPopupMenu_Separator0.isValid());
assertEquals(true, jPopupMenu_Separator0.isBackgroundSet());
assertEquals(false, jPopupMenu_Separator0.isPreferredSizeSet());
assertEquals(0, jPopupMenu_Separator0.countComponents());
assertEquals(true, jPopupMenu_Separator0.isForegroundSet());
assertEquals(true, jPopupMenu_Separator0.getFocusTraversalKeysEnabled());
assertEquals(false, jPopupMenu_Separator0.isDisplayable());
assertEquals(false, jPopupMenu_Separator0.isMinimumSizeSet());
}
@Test
public void test042() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertNotNull(combinedDomainXYPlot0);
FastScatterPlot fastScatterPlot0 = new FastScatterPlot();
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertNotNull(fastScatterPlot0);
NumberAxis numberAxis0 = (NumberAxis)fastScatterPlot0.getRangeAxis();
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertNotNull(numberAxis0);
int int0 = 0;
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot((ValueAxis) numberAxis0);
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNotNull(combinedRangeCategoryPlot0);
CategoryAxis categoryAxis0 = combinedRangeCategoryPlot0.getDomainAxisForDataset(int0);
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNull(categoryAxis0);
CombinedDomainCategoryPlot combinedDomainCategoryPlot0 = new CombinedDomainCategoryPlot(categoryAxis0);
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertNotNull(combinedDomainCategoryPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedDomainCategoryPlot0.getDomainGridlineStroke();
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertNotNull(basicStroke0);
combinedDomainXYPlot0.setRangeZeroBaselineStroke((Stroke) basicStroke0);
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
}
@Test
public void test043() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
int int0 = 0;
XYPlot xYPlot0 = new XYPlot();
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNotNull(xYPlot0);
VectorSeriesCollection vectorSeriesCollection0 = new VectorSeriesCollection();
// // Unstable assertion: assertEquals(0, vectorSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertNotNull(vectorSeriesCollection0);
int int1 = xYPlot0.indexOf((XYDataset) vectorSeriesCollection0);
// // Unstable assertion: assertEquals(0, vectorSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertFalse(int1 == int0);
// // Unstable assertion: assertEquals((-1), int1);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
XYLine3DRenderer xYLine3DRenderer0 = new XYLine3DRenderer();
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesFilled());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseLinesVisible());
// // Unstable assertion: assertEquals(8.0, xYLine3DRenderer0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getDrawOutlines());
// // Unstable assertion: assertEquals(2.0, xYLine3DRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(12.0, xYLine3DRenderer0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getDrawSeriesLineAsPath());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertNotNull(xYLine3DRenderer0);
Color color0 = (Color)xYLine3DRenderer0.getItemPaint(int1, int0);
// // Unstable assertion: assertEquals(0, vectorSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesFilled());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseLinesVisible());
// // Unstable assertion: assertEquals(8.0, xYLine3DRenderer0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getDrawOutlines());
// // Unstable assertion: assertEquals(2.0, xYLine3DRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(12.0, xYLine3DRenderer0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getDrawSeriesLineAsPath());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertFalse(int1 == int0);
// // Unstable assertion: assertFalse(int0 == int1);
// // Unstable assertion: assertNotNull(color0);
combinedDomainXYPlot0.setDomainZeroBaselinePaint((Paint) color0);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0, vectorSeriesCollection0.getSeriesCount());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesFilled());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseLinesVisible());
// // Unstable assertion: assertEquals(8.0, xYLine3DRenderer0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getDrawOutlines());
// // Unstable assertion: assertEquals(2.0, xYLine3DRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(12.0, xYLine3DRenderer0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getDrawSeriesLineAsPath());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertFalse(int1 == int0);
// // Unstable assertion: assertFalse(int0 == int1);
}
@Test
public void test044() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertNotNull(combinedDomainXYPlot0);
Stroke stroke0 = null;
// Undeclared exception!
try {
combinedDomainXYPlot0.setDomainZeroBaselineStroke(stroke0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Null 'stroke' argument.
//
}
}
@Test
public void test045() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedDomainXYPlot0.getRangeGridlineStroke();
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(basicStroke0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertNotNull(combinedRangeXYPlot0);
combinedRangeXYPlot0.setDomainZeroBaselineStroke((Stroke) basicStroke0);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
}
@Test
public void test046() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedDomainXYPlot0);
Paint paint0 = null;
// Undeclared exception!
try {
combinedDomainXYPlot0.setRangeGridlinePaint(paint0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Null 'paint' argument.
//
}
}
@Test
public void test047() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeZoomable());
assertNotNull(xYPlot0);
Color color0 = (Color)xYPlot0.getRangeZeroBaselinePaint();
assertEquals(-16777216, color0.getRGB());
assertEquals(1, color0.getTransparency());
assertEquals("java.awt.Color[r=0,g=0,b=0]", color0.toString());
assertEquals(0, color0.getRed());
assertEquals(0, color0.getGreen());
assertEquals(0, color0.getBlue());
assertEquals(255, color0.getAlpha());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeZoomable());
assertNotNull(color0);
xYPlot0.setRangeGridlinePaint((Paint) color0);
assertEquals(-16777216, color0.getRGB());
assertEquals(1, color0.getTransparency());
assertEquals("java.awt.Color[r=0,g=0,b=0]", color0.toString());
assertEquals(0, color0.getRed());
assertEquals(0, color0.getGreen());
assertEquals(0, color0.getBlue());
assertEquals(255, color0.getAlpha());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isRangeZoomable());
}
@Test
public void test048() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)dateAxis0.getTickMarkStroke();
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertNotNull(basicStroke0);
combinedDomainXYPlot0.setRangeGridlineStroke((Stroke) basicStroke0);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
}
@Test
public void test049() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertNotNull(combinedRangeXYPlot0);
boolean boolean0 = false;
combinedRangeXYPlot0.setRangeGridlinesVisible(boolean0);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
}
@Test
public void test050() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
ValueAxis valueAxis0 = combinedRangeXYPlot0.getDomainAxisForDataset(int0);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNull(valueAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot(valueAxis0);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = true;
combinedDomainXYPlot0.setRangeGridlinesVisible(boolean0);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
}
@Test
public void test051() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertNotNull(combinedDomainXYPlot0);
int int0 = combinedDomainXYPlot0.getSeriesCount();
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0, int0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedRangeXYPlot0);
XYErrorRenderer xYErrorRenderer0 = new XYErrorRenderer();
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(2.0, xYErrorRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(3, xYErrorRenderer0.getDefaultEntityRadius());
assertEquals(4.0, xYErrorRenderer0.getCapLength(), 0.01D);
assertEquals(false, xYErrorRenderer0.getUseOutlinePaint());
assertEquals(true, xYErrorRenderer0.getBaseSeriesVisible());
assertEquals(false, xYErrorRenderer0.getUseFillPaint());
assertEquals(true, xYErrorRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, xYErrorRenderer0.getBaseShapesFilled());
assertEquals(false, xYErrorRenderer0.getDrawSeriesLineAsPath());
assertEquals(true, xYErrorRenderer0.getDrawXError());
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, xYErrorRenderer0.getBaseShapesVisible());
assertEquals(true, xYErrorRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, xYErrorRenderer0.getDrawYError());
assertEquals(2, xYErrorRenderer0.getPassCount());
assertEquals(false, xYErrorRenderer0.getBaseItemLabelsVisible());
assertEquals(true, xYErrorRenderer0.getBaseCreateEntities());
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, xYErrorRenderer0.getDrawOutlines());
assertEquals(true, xYErrorRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, xYErrorRenderer0.getBaseLinesVisible());
assertNotNull(xYErrorRenderer0);
Paint paint0 = xYErrorRenderer0.getSeriesOutlinePaint(int0);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(2.0, xYErrorRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(3, xYErrorRenderer0.getDefaultEntityRadius());
assertEquals(4.0, xYErrorRenderer0.getCapLength(), 0.01D);
assertEquals(false, xYErrorRenderer0.getUseOutlinePaint());
assertEquals(true, xYErrorRenderer0.getBaseSeriesVisible());
assertEquals(false, xYErrorRenderer0.getUseFillPaint());
assertEquals(true, xYErrorRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, xYErrorRenderer0.getBaseShapesFilled());
assertEquals(false, xYErrorRenderer0.getDrawSeriesLineAsPath());
assertEquals(true, xYErrorRenderer0.getDrawXError());
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, xYErrorRenderer0.getBaseShapesVisible());
assertEquals(true, xYErrorRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, xYErrorRenderer0.getDrawYError());
assertEquals(2, xYErrorRenderer0.getPassCount());
assertEquals(false, xYErrorRenderer0.getBaseItemLabelsVisible());
assertEquals(true, xYErrorRenderer0.getBaseCreateEntities());
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, xYErrorRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, xYErrorRenderer0.getDrawOutlines());
assertEquals(true, xYErrorRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, xYErrorRenderer0.getBaseLinesVisible());
assertNull(paint0);
// Undeclared exception!
try {
combinedRangeXYPlot0.setDomainGridlinePaint(paint0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Null 'paint' argument.
//
}
}
@Test
public void test052() throws Throwable {
VectorRenderer vectorRenderer0 = new VectorRenderer();
assertEquals(2.0, vectorRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(3, vectorRenderer0.getDefaultEntityRadius());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, vectorRenderer0.getBaseSeriesVisible());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, vectorRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, vectorRenderer0.getBaseCreateEntities());
assertEquals(true, vectorRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, vectorRenderer0.getPassCount());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, vectorRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, vectorRenderer0.getBaseItemLabelsVisible());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesOutlineStroke());
assertNotNull(vectorRenderer0);
int int0 = (-934);
Color color0 = (Color)vectorRenderer0.lookupSeriesFillPaint(int0);
assertEquals(2.0, vectorRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(3, vectorRenderer0.getDefaultEntityRadius());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, vectorRenderer0.getBaseSeriesVisible());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, vectorRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, vectorRenderer0.getBaseCreateEntities());
assertEquals(true, vectorRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, vectorRenderer0.getPassCount());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, vectorRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, vectorRenderer0.getBaseItemLabelsVisible());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(-1, color0.getRGB());
assertEquals(255, color0.getBlue());
assertEquals(255, color0.getAlpha());
assertEquals(255, color0.getGreen());
assertEquals(1, color0.getTransparency());
assertEquals("java.awt.Color[r=255,g=255,b=255]", color0.toString());
assertEquals(255, color0.getRed());
assertNotNull(color0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNotNull(combinedDomainXYPlot0);
combinedDomainXYPlot0.setDomainGridlinePaint((Paint) color0);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(2.0, vectorRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(3, vectorRenderer0.getDefaultEntityRadius());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, vectorRenderer0.getBaseSeriesVisible());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, vectorRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, vectorRenderer0.getBaseCreateEntities());
assertEquals(true, vectorRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, vectorRenderer0.getPassCount());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, vectorRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, vectorRenderer0.getBaseItemLabelsVisible());
assertEquals(false, vectorRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(-1, color0.getRGB());
assertEquals(255, color0.getBlue());
assertEquals(255, color0.getAlpha());
assertEquals(255, color0.getGreen());
assertEquals(1, color0.getTransparency());
assertEquals("java.awt.Color[r=255,g=255,b=255]", color0.toString());
assertEquals(255, color0.getRed());
}
@Test
public void test053() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedDomainXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)AbstractRenderer.DEFAULT_OUTLINE_STROKE;
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(2, basicStroke0.getEndCap());
assertEquals(0, basicStroke0.getLineJoin());
assertNotNull(basicStroke0);
combinedDomainXYPlot0.setDomainGridlineStroke((Stroke) basicStroke0);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(2, basicStroke0.getEndCap());
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
}
@Test
public void test054() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isOutlineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isSubplot());
assertNotNull(xYPlot0);
boolean boolean0 = false;
xYPlot0.setDomainGridlinesVisible(boolean0);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isOutlineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isSubplot());
}
@Test
public void test055() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertNotNull(combinedRangeXYPlot0);
Rectangle2D.Double rectangle2D_Double0 = (Rectangle2D.Double)Plot.DEFAULT_LEGEND_ITEM_BOX;
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertNotNull(rectangle2D_Double0);
boolean boolean0 = rectangle2D_Double0.isEmpty();
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertTrue(boolean0);
combinedRangeXYPlot0.setDomainGridlinesVisible(boolean0);
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
}
@Test
public void test056() throws Throwable {
NumberAxis3D numberAxis3D0 = new NumberAxis3D();
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(1.0, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(false, numberAxis3D0.isInverted());
assertNull(numberAxis3D0.getLabelURL());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertNotNull(numberAxis3D0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot((ValueAxis) numberAxis3D0);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(false, numberAxis3D0.isInverted());
assertNull(numberAxis3D0.getLabelURL());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
MatrixSeriesCollection matrixSeriesCollection0 = new MatrixSeriesCollection();
assertEquals(0, matrixSeriesCollection0.getSeriesCount());
assertNotNull(matrixSeriesCollection0);
XYItemRenderer xYItemRenderer0 = combinedRangeXYPlot0.getRendererForDataset((XYDataset) matrixSeriesCollection0);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0, matrixSeriesCollection0.getSeriesCount());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(false, numberAxis3D0.isInverted());
assertNull(numberAxis3D0.getLabelURL());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertNull(xYItemRenderer0);
}
@Test
public void test057() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertNotNull(combinedDomainXYPlot0);
SeriesRenderingOrder seriesRenderingOrder0 = null;
// Undeclared exception!
try {
combinedDomainXYPlot0.setSeriesRenderingOrder(seriesRenderingOrder0);
fail("Expecting exception: IllegalArgumentException");
} catch(IllegalArgumentException e) {
//
// Null 'order' argument.
//
}
}
@Test
public void test058() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
SeriesRenderingOrder seriesRenderingOrder0 = SeriesRenderingOrder.FORWARD;
assertEquals("SeriesRenderingOrder.FORWARD", seriesRenderingOrder0.toString());
assertNotNull(seriesRenderingOrder0);
combinedRangeXYPlot0.setSeriesRenderingOrder(seriesRenderingOrder0);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("SeriesRenderingOrder.FORWARD", seriesRenderingOrder0.toString());
}
@Test
public void test059() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
DatasetRenderingOrder datasetRenderingOrder0 = DatasetRenderingOrder.FORWARD;
assertEquals("DatasetRenderingOrder.FORWARD", datasetRenderingOrder0.toString());
assertNotNull(datasetRenderingOrder0);
combinedRangeXYPlot0.setDatasetRenderingOrder(datasetRenderingOrder0);
assertEquals("DatasetRenderingOrder.FORWARD", datasetRenderingOrder0.toString());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
}
@Test
public void test060() throws Throwable {
NumberAxis3D numberAxis3D0 = new NumberAxis3D();
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(1.0, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertNotNull(numberAxis3D0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot((ValueAxis) numberAxis3D0);
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNotNull(combinedRangeXYPlot0);
XYItemRenderer[] xYItemRendererArray0 = new XYItemRenderer[3];
combinedRangeXYPlot0.setRenderers(xYItemRendererArray0);
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(true, numberAxis3D0.isVisible());
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
}
@Test
public void test061() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedRangeXYPlot0);
EvoSuiteFile evoSuiteFile0 = null;
String string0 = "S_=7oi~";
boolean boolean0 = FileSystemHandling.appendStringToFile(evoSuiteFile0, string0);
assertFalse(boolean0);
int int0 = 810;
StandardXYToolTipGenerator standardXYToolTipGenerator0 = StandardXYToolTipGenerator.getTimeSeriesInstance();
assertEquals("{0}: ({1}, {2})", standardXYToolTipGenerator0.getFormatString());
assertNotNull(standardXYToolTipGenerator0);
StandardXYItemRenderer standardXYItemRenderer0 = new StandardXYItemRenderer(int0, (XYToolTipGenerator) standardXYToolTipGenerator0);
assertEquals(1.0, standardXYItemRenderer0.getGapThreshold(), 0.01D);
assertEquals(true, standardXYItemRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, standardXYItemRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, standardXYItemRenderer0.getBaseShapesVisible());
assertEquals(2.0, standardXYItemRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1, standardXYItemRenderer0.getPassCount());
assertEquals(3, standardXYItemRenderer0.getDefaultEntityRadius());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, standardXYItemRenderer0.getBaseItemLabelsVisible());
assertEquals(false, standardXYItemRenderer0.getDrawSeriesLineAsPath());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, standardXYItemRenderer0.getBaseShapesFilled());
assertEquals(false, standardXYItemRenderer0.getPlotImages());
assertEquals(true, standardXYItemRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, standardXYItemRenderer0.getPlotDiscontinuous());
assertEquals(true, standardXYItemRenderer0.getBaseCreateEntities());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, standardXYItemRenderer0.getBaseSeriesVisible());
assertEquals(true, standardXYItemRenderer0.getPlotLines());
assertEquals("{0}: ({1}, {2})", standardXYToolTipGenerator0.getFormatString());
assertNotNull(standardXYItemRenderer0);
combinedRangeXYPlot0.setRenderer(int0, (XYItemRenderer) standardXYItemRenderer0, boolean0);
assertEquals(1.0, standardXYItemRenderer0.getGapThreshold(), 0.01D);
assertEquals(true, standardXYItemRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, standardXYItemRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, standardXYItemRenderer0.getBaseShapesVisible());
assertEquals(2.0, standardXYItemRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1, standardXYItemRenderer0.getPassCount());
assertEquals(3, standardXYItemRenderer0.getDefaultEntityRadius());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, standardXYItemRenderer0.getBaseItemLabelsVisible());
assertEquals(false, standardXYItemRenderer0.getDrawSeriesLineAsPath());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, standardXYItemRenderer0.getBaseShapesFilled());
assertEquals(false, standardXYItemRenderer0.getPlotImages());
assertEquals(true, standardXYItemRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, standardXYItemRenderer0.getPlotDiscontinuous());
assertEquals(true, standardXYItemRenderer0.getBaseCreateEntities());
assertEquals(false, standardXYItemRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, standardXYItemRenderer0.getBaseSeriesVisible());
assertEquals(true, standardXYItemRenderer0.getPlotLines());
assertEquals("{0}: ({1}, {2})", standardXYToolTipGenerator0.getFormatString());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
}
@Test
public void test062() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedRangeXYPlot0);
int int0 = combinedRangeXYPlot0.getWeight();
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, int0);
TimeSeriesCollection timeSeriesCollection0 = new TimeSeriesCollection();
assertEquals(0, timeSeriesCollection0.getSeriesCount());
assertNotNull(timeSeriesCollection0);
combinedRangeXYPlot0.setDataset(int0, (XYDataset) timeSeriesCollection0);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0, timeSeriesCollection0.getSeriesCount());
}
@Test
public void test063() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNotNull(combinedDomainXYPlot0);
FastScatterPlot fastScatterPlot0 = new FastScatterPlot();
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertNotNull(fastScatterPlot0);
NumberAxis numberAxis0 = (NumberAxis)fastScatterPlot0.getRangeAxis();
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertNull(numberAxis0.getLabelURL());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals("Y", numberAxis0.getLabel());
assertNotNull(numberAxis0);
int int0 = combinedDomainXYPlot0.getDomainAxisIndex((ValueAxis) numberAxis0);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertNull(numberAxis0.getLabelURL());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals("Y", numberAxis0.getLabel());
assertEquals((-1), int0);
RectangleEdge rectangleEdge0 = combinedDomainXYPlot0.getRangeAxisEdge(int0);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("RectangleEdge.RIGHT", rectangleEdge0.toString());
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertNull(numberAxis0.getLabelURL());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals("Y", numberAxis0.getLabel());
assertNotNull(rectangleEdge0);
}
@Test
public void test064() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
combinedDomainXYPlot0.clearRangeAxes();
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
}
@Test
public void test065() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNotNull(combinedRangeXYPlot0);
ValueAxis[] valueAxisArray0 = new ValueAxis[19];
combinedRangeXYPlot0.setRangeAxes(valueAxisArray0);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
}
@Test
public void test066() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot();
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNotNull(combinedRangeCategoryPlot0);
int int0 = 2193;
ValueAxis valueAxis0 = combinedRangeCategoryPlot0.getRangeAxis(int0);
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(valueAxis0);
combinedDomainXYPlot0.setRangeAxis(valueAxis0);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
}
@Test
public void test067() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot();
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNotNull(combinedRangeCategoryPlot0);
AxisLocation axisLocation0 = combinedRangeCategoryPlot0.getRangeAxisLocation(int0);
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals("AxisLocation.TOP_OR_LEFT", axisLocation0.toString());
// // Unstable assertion: assertNotNull(axisLocation0);
boolean boolean0 = false;
combinedDomainXYPlot0.setDomainAxisLocation(axisLocation0, boolean0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals("AxisLocation.TOP_OR_LEFT", axisLocation0.toString());
}
@Test
public void test068() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
ValueAxis valueAxis0 = combinedRangeXYPlot0.getDomainAxisForDataset(int0);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNull(valueAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot(valueAxis0);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNotNull(combinedDomainXYPlot0);
RectangleEdge rectangleEdge0 = combinedDomainXYPlot0.getDomainAxisEdge(int0);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals("RectangleEdge.BOTTOM", rectangleEdge0.toString());
assertNotNull(rectangleEdge0);
}
@Test
public void test069() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
ValueAxis valueAxis0 = combinedRangeXYPlot0.getDomainAxisForDataset(int0);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(valueAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot(valueAxis0);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedDomainXYPlot0);
int int1 = 28;
RectangleEdge rectangleEdge0 = combinedDomainXYPlot0.getDomainAxisEdge(int1);
assertEquals("RectangleEdge.TOP", rectangleEdge0.toString());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertFalse(int0 == int1);
assertFalse(int1 == int0);
assertNotNull(rectangleEdge0);
}
@Test
public void test070() throws Throwable {
NumberAxis3D numberAxis3D0 = new NumberAxis3D();
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(true, numberAxis3D0.isVisible());
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(1.0, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertNotNull(numberAxis3D0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot((ValueAxis) numberAxis3D0);
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(true, numberAxis3D0.isVisible());
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertNotNull(combinedRangeXYPlot0);
combinedRangeXYPlot0.clearDomainAxes();
assertEquals(false, numberAxis3D0.isVerticalTickLabels());
assertEquals(false, numberAxis3D0.isInverted());
assertEquals(true, numberAxis3D0.isAutoRange());
assertEquals(true, numberAxis3D0.isVisible());
assertNull(numberAxis3D0.getLabelToolTip());
assertEquals(2.0F, numberAxis3D0.getTickMarkOutsideLength(), 0.01F);
assertEquals(false, numberAxis3D0.isAxisLineVisible());
assertEquals(true, numberAxis3D0.getAutoRangeStickyZero());
assertNull(numberAxis3D0.getLabel());
assertEquals(0.0, numberAxis3D0.getLabelAngle(), 0.01D);
assertEquals(true, numberAxis3D0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis3D0.isAutoTickUnitSelection());
assertEquals(false, numberAxis3D0.isNegativeArrowVisible());
assertEquals(0.05, numberAxis3D0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis3D0.isPositiveArrowVisible());
assertEquals(1.05, numberAxis3D0.getUpperBound(), 0.01D);
assertEquals(0.0F, numberAxis3D0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, numberAxis3D0.getFixedAutoRange(), 0.01D);
assertEquals(0.0, numberAxis3D0.getFixedDimension(), 0.01D);
assertNull(numberAxis3D0.getLabelURL());
assertEquals(0.05, numberAxis3D0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis3D0.isTickLabelsVisible());
assertEquals(0.0, numberAxis3D0.getLowerBound(), 0.01D);
assertEquals(1.0E-8, numberAxis3D0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, numberAxis3D0.isTickMarksVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
}
@Test
public void test071() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertNotNull(combinedDomainXYPlot0);
FastScatterPlot fastScatterPlot0 = new FastScatterPlot();
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertNotNull(fastScatterPlot0);
NumberAxis numberAxis0 = (NumberAxis)fastScatterPlot0.getRangeAxis();
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertNull(numberAxis0.getLabelURL());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isVisible());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertNotNull(numberAxis0);
int int0 = 811;
combinedDomainXYPlot0.setDomainAxis(int0, (ValueAxis) numberAxis0);
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertNull(numberAxis0.getLabelURL());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isVisible());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
}
@Test
public void test072() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertNotNull(combinedDomainXYPlot0);
String string0 = "v";
DateAxis dateAxis0 = new DateAxis(string0);
assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, dateAxis0.isTickLabelsVisible());
assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
assertEquals(true, dateAxis0.isAutoRange());
assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
assertEquals(true, dateAxis0.isVisible());
assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(false, dateAxis0.isNegativeArrowVisible());
assertEquals("v", dateAxis0.getLabel());
assertEquals(true, dateAxis0.isAutoTickUnitSelection());
assertEquals(false, dateAxis0.isVerticalTickLabels());
assertEquals(true, dateAxis0.isTickMarksVisible());
assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
assertEquals(false, dateAxis0.isPositiveArrowVisible());
assertEquals(true, dateAxis0.isAxisLineVisible());
assertNull(dateAxis0.getLabelURL());
assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
assertNull(dateAxis0.getLabelToolTip());
assertEquals(false, dateAxis0.isInverted());
assertNotNull(dateAxis0);
ValueAxis[] valueAxisArray0 = new ValueAxis[5];
valueAxisArray0[0] = (ValueAxis) dateAxis0;
assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, dateAxis0.isTickLabelsVisible());
assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
assertEquals(true, dateAxis0.isAutoRange());
assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
assertEquals(true, dateAxis0.isVisible());
assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(false, dateAxis0.isNegativeArrowVisible());
assertEquals("v", dateAxis0.getLabel());
assertEquals(true, dateAxis0.isAutoTickUnitSelection());
assertEquals(false, dateAxis0.isVerticalTickLabels());
assertEquals(true, dateAxis0.isTickMarksVisible());
assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
assertEquals(false, dateAxis0.isPositiveArrowVisible());
assertEquals(true, dateAxis0.isAxisLineVisible());
assertNull(dateAxis0.getLabelURL());
assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
assertNull(dateAxis0.getLabelToolTip());
assertEquals(false, dateAxis0.isInverted());
assertEquals(true, valueAxisArray0[0].isAxisLineVisible());
assertEquals("v", valueAxisArray0[0].getLabel());
assertEquals(0.0, valueAxisArray0[0].getFixedDimension(), 0.01D);
assertEquals(false, valueAxisArray0[0].isInverted());
assertEquals(true, valueAxisArray0[0].isAutoRange());
assertEquals(false, valueAxisArray0[0].isVerticalTickLabels());
assertEquals(true, valueAxisArray0[0].isTickLabelsVisible());
assertEquals(2.0, valueAxisArray0[0].getAutoRangeMinimumSize(), 0.01D);
assertEquals(true, valueAxisArray0[0].isTickMarksVisible());
assertEquals(true, valueAxisArray0[0].isVisible());
assertEquals(0.0F, valueAxisArray0[0].getTickMarkInsideLength(), 0.01F);
assertEquals(0.0, valueAxisArray0[0].getLabelAngle(), 0.01D);
assertEquals(false, valueAxisArray0[0].isPositiveArrowVisible());
assertNull(valueAxisArray0[0].getLabelToolTip());
assertEquals(true, valueAxisArray0[0].isAutoTickUnitSelection());
assertEquals(0.05, valueAxisArray0[0].getUpperMargin(), 0.01D);
assertEquals(2.0F, valueAxisArray0[0].getTickMarkOutsideLength(), 0.01F);
assertEquals(false, valueAxisArray0[0].isNegativeArrowVisible());
assertNull(valueAxisArray0[0].getLabelURL());
assertEquals(0.05, valueAxisArray0[0].getLowerMargin(), 0.01D);
assertEquals(0.0, valueAxisArray0[0].getFixedAutoRange(), 0.01D);
assertEquals(0.0, valueAxisArray0[0].getLowerBound(), 0.01D);
assertEquals(1.0, valueAxisArray0[0].getUpperBound(), 0.01D);
assertNotNull(valueAxisArray0[0]);
combinedDomainXYPlot0.setDomainAxes(valueAxisArray0);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
}
@Test
public void test073() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNotNull(combinedRangeXYPlot0);
RectangleInsets rectangleInsets0 = Axis.DEFAULT_TICK_LABEL_INSETS;
assertEquals(4.0, rectangleInsets0.getLeft(), 0.01D);
assertEquals(2.0, rectangleInsets0.getTop(), 0.01D);
assertEquals(2.0, rectangleInsets0.getBottom(), 0.01D);
assertEquals(4.0, rectangleInsets0.getRight(), 0.01D);
assertNotNull(rectangleInsets0);
combinedRangeXYPlot0.setAxisOffset(rectangleInsets0);
assertEquals(4.0, rectangleInsets0.getLeft(), 0.01D);
assertEquals(2.0, rectangleInsets0.getTop(), 0.01D);
assertEquals(2.0, rectangleInsets0.getBottom(), 0.01D);
assertEquals(4.0, rectangleInsets0.getRight(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
}
@Test
public void test074() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
ValueAxis valueAxis0 = combinedRangeXYPlot0.getDomainAxisForDataset(int0);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNull(valueAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot(valueAxis0);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedDomainXYPlot0);
PlotOrientation plotOrientation0 = combinedDomainXYPlot0.getOrientation();
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals("PlotOrientation.VERTICAL", plotOrientation0.toString());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertNotNull(plotOrientation0);
combinedDomainXYPlot0.setOrientation(plotOrientation0);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals("PlotOrientation.VERTICAL", plotOrientation0.toString());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
}
@Test
public void test075() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = combinedDomainXYPlot0.isDomainGridlinesVisible();
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertTrue(boolean0);
}
@Test
public void test076() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertNotNull(combinedRangeXYPlot0);
Rectangle2D.Double rectangle2D_Double0 = (Rectangle2D.Double)Plot.DEFAULT_LEGEND_ITEM_BOX;
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertNotNull(rectangle2D_Double0);
Rectangle2D.Double rectangle2D_Double1 = (Rectangle2D.Double)rectangle2D_Double0.getFrame();
// // Unstable assertion: assertNotSame(rectangle2D_Double1, rectangle2D_Double0);
// // Unstable assertion: assertNotSame(rectangle2D_Double0, rectangle2D_Double1);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertTrue(rectangle2D_Double1.equals((Object)rectangle2D_Double0));
// // Unstable assertion: assertTrue(rectangle2D_Double0.equals((Object)rectangle2D_Double1));
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
// // Unstable assertion: assertNotNull(rectangle2D_Double1);
Graphics2D graphics2D0 = null;
combinedRangeXYPlot0.drawZeroDomainBaseline(graphics2D0, rectangle2D_Double1);
// // Unstable assertion: assertNotSame(rectangle2D_Double1, rectangle2D_Double0);
// // Unstable assertion: assertNotSame(rectangle2D_Double0, rectangle2D_Double1);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinY(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMinX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getCenterX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxX(), 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.getMaxY(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertNull(combinedRangeXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedRangeXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertTrue(rectangle2D_Double1.equals((Object)rectangle2D_Double0));
// // Unstable assertion: assertTrue(rectangle2D_Double0.equals((Object)rectangle2D_Double1));
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.width, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double1.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.y, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.x, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.height, 0.01D);
// // Unstable assertion: assertEquals(0.0, rectangle2D_Double0.width, 0.01D);
}
@Test
public void test077() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertNotNull(combinedDomainXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedDomainXYPlot0.getRangeZeroBaselineStroke();
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertNotNull(basicStroke0);
}
@Test
public void test078() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertNotNull(xYPlot0);
int int0 = 30;
Layer layer0 = null;
IntervalMarker intervalMarker0 = new IntervalMarker((double) int0, (double) int0);
assertEquals(0.8F, intervalMarker0.getAlpha(), 0.01F);
assertEquals(30.0, intervalMarker0.getEndValue(), 0.01D);
assertEquals(30.0, intervalMarker0.getStartValue(), 0.01D);
assertNull(intervalMarker0.getLabel());
assertNotNull(intervalMarker0);
boolean boolean0 = xYPlot0.removeRangeMarker(int0, (Marker) intervalMarker0, layer0);
assertEquals(0.8F, intervalMarker0.getAlpha(), 0.01F);
assertEquals(30.0, intervalMarker0.getEndValue(), 0.01D);
assertEquals(30.0, intervalMarker0.getStartValue(), 0.01D);
assertNull(intervalMarker0.getLabel());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertFalse(boolean0);
}
@Test
public void test079() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedDomainXYPlot0);
RectangleInsets rectangleInsets0 = combinedDomainXYPlot0.getAxisOffset();
assertEquals(4.0, rectangleInsets0.getBottom(), 0.01D);
assertEquals(4.0, rectangleInsets0.getTop(), 0.01D);
assertEquals(4.0, rectangleInsets0.getLeft(), 0.01D);
assertEquals(4.0, rectangleInsets0.getRight(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertNotNull(rectangleInsets0);
}
@Test
public void test080() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNotNull(combinedRangeXYPlot0);
int int0 = (-1058);
AxisLocation axisLocation0 = combinedRangeXYPlot0.getDomainAxisLocation(int0);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals("AxisLocation.TOP_OR_RIGHT", axisLocation0.toString());
assertNotNull(axisLocation0);
combinedRangeXYPlot0.setDomainAxisLocation(axisLocation0);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals("AxisLocation.TOP_OR_RIGHT", axisLocation0.toString());
}
@Test
public void test081() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNotNull(combinedDomainXYPlot0);
double double0 = combinedDomainXYPlot0.getDomainCrosshairValue();
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, double0, 0.01D);
}
@Test
public void test082() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertNotNull(combinedRangeXYPlot0);
RectangleEdge rectangleEdge0 = combinedRangeXYPlot0.getDomainAxisEdge();
assertEquals("RectangleEdge.BOTTOM", rectangleEdge0.toString());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertNotNull(rectangleEdge0);
}
@Test
public void test083() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertNotNull(combinedDomainXYPlot0);
DatasetRenderingOrder datasetRenderingOrder0 = combinedDomainXYPlot0.getDatasetRenderingOrder();
assertEquals("DatasetRenderingOrder.REVERSE", datasetRenderingOrder0.toString());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertNotNull(datasetRenderingOrder0);
}
@Test
public void test084() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertNotNull(combinedDomainXYPlot0);
int int0 = 0;
String string0 = "v";
DateAxis dateAxis0 = new DateAxis(string0);
assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
assertEquals(false, dateAxis0.isPositiveArrowVisible());
assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
assertEquals(true, dateAxis0.isAutoRange());
assertEquals(true, dateAxis0.isAutoTickUnitSelection());
assertEquals(true, dateAxis0.isTickLabelsVisible());
assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(dateAxis0.getLabelURL());
assertEquals(false, dateAxis0.isInverted());
assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
assertEquals(true, dateAxis0.isTickMarksVisible());
assertEquals(false, dateAxis0.isVerticalTickLabels());
assertEquals(true, dateAxis0.isVisible());
assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
assertEquals("v", dateAxis0.getLabel());
assertEquals(true, dateAxis0.isAxisLineVisible());
assertNull(dateAxis0.getLabelToolTip());
assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
assertEquals(false, dateAxis0.isNegativeArrowVisible());
assertNotNull(dateAxis0);
combinedDomainXYPlot0.setRangeAxis(int0, (ValueAxis) dateAxis0);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
assertEquals(false, dateAxis0.isPositiveArrowVisible());
assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
assertEquals(true, dateAxis0.isAutoRange());
assertEquals(true, dateAxis0.isAutoTickUnitSelection());
assertEquals(true, dateAxis0.isTickLabelsVisible());
assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
assertNull(dateAxis0.getLabelURL());
assertEquals(false, dateAxis0.isInverted());
assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
assertEquals(true, dateAxis0.isTickMarksVisible());
assertEquals(false, dateAxis0.isVerticalTickLabels());
assertEquals(true, dateAxis0.isVisible());
assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
assertEquals("v", dateAxis0.getLabel());
assertEquals(true, dateAxis0.isAxisLineVisible());
assertNull(dateAxis0.getLabelToolTip());
assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
assertEquals(false, dateAxis0.isNegativeArrowVisible());
}
@Test
public void test085() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedDomainXYPlot0.getDomainZeroBaselineStroke();
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertNotNull(basicStroke0);
}
@Test
public void test086() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertNotNull(xYPlot0);
xYPlot0.clearAnnotations();
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
}
@Test
public void test087() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNotNull(combinedDomainXYPlot0);
int int0 = (-1058);
combinedDomainXYPlot0.setWeight(int0);
assertEquals(-1058, combinedDomainXYPlot0.getWeight());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
}
@Test
public void test088() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertNotNull(combinedDomainXYPlot0);
XYDataset xYDataset0 = null;
XYItemRenderer xYItemRenderer0 = combinedDomainXYPlot0.getRendererForDataset(xYDataset0);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertNull(xYItemRenderer0);
}
@Test
public void test089() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainZoomable());
assertNotNull(xYPlot0);
Color color0 = (Color)xYPlot0.getDomainGridlinePaint();
assertEquals(-1, color0.getRGB());
assertEquals(255, color0.getAlpha());
assertEquals("java.awt.Color[r=255,g=255,b=255]", color0.toString());
assertEquals(255, color0.getGreen());
assertEquals(255, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(255, color0.getBlue());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainZoomable());
assertNotNull(color0);
}
@Test
public void test090() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(combinedDomainXYPlot0);
RectangleEdge rectangleEdge0 = combinedDomainXYPlot0.getRangeAxisEdge();
assertEquals("RectangleEdge.LEFT", rectangleEdge0.toString());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(rectangleEdge0);
}
@Test
public void test091() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(xYPlot0);
double double0 = xYPlot0.getRangeCrosshairValue();
assertEquals(false, xYPlot0.isSubplot());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isOutlineVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, double0, 0.01D);
}
@Test
public void test092() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertNotNull(combinedDomainXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedDomainXYPlot0.getRangeGridlineStroke();
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertNotNull(basicStroke0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertNotNull(combinedRangeXYPlot0);
RendererChangeEvent rendererChangeEvent0 = new RendererChangeEvent((Object) basicStroke0);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertNotNull(rendererChangeEvent0);
combinedRangeXYPlot0.rendererChanged(rendererChangeEvent0);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
}
@Test
public void test093() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNotNull(combinedDomainXYPlot0);
Layer layer0 = Layer.FOREGROUND;
assertEquals("Layer.FOREGROUND", layer0.toString());
assertNotNull(layer0);
Collection collection0 = combinedDomainXYPlot0.getRangeMarkers(layer0);
assertEquals("Layer.FOREGROUND", layer0.toString());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNull(collection0);
}
@Test
public void test094() throws Throwable {
boolean boolean0 = false;
XYPlot xYPlot0 = new XYPlot();
assertEquals(false, xYPlot0.isSubplot());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(1, xYPlot0.getWeight());
assertNotNull(xYPlot0);
ValueAxis valueAxis0 = null;
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot(valueAxis0);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNotNull(combinedRangeXYPlot0);
AxisLocation axisLocation0 = combinedRangeXYPlot0.getRangeAxisLocation();
assertEquals("AxisLocation.BOTTOM_OR_LEFT", axisLocation0.toString());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNotNull(axisLocation0);
xYPlot0.setRangeAxisLocation(axisLocation0, boolean0);
assertEquals("AxisLocation.BOTTOM_OR_LEFT", axisLocation0.toString());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(1, xYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
}
@Test
public void test095() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = combinedDomainXYPlot0.isRangeGridlinesVisible();
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertTrue(boolean0);
}
@Test
public void test096() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNotNull(combinedRangeXYPlot0);
AxisSpace axisSpace0 = combinedRangeXYPlot0.getFixedDomainAxisSpace();
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertNull(axisSpace0);
}
@Test
public void test097() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
List list0 = combinedDomainXYPlot0.getAnnotations();
// // Unstable assertion: assertEquals(0, list0.size());
// // Unstable assertion: assertEquals(true, list0.isEmpty());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertNotNull(list0);
}
@Test
public void test098() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)dateAxis0.getTickMarkStroke();
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertNotNull(basicStroke0);
StackedBarRenderer3D stackedBarRenderer3D0 = new StackedBarRenderer3D();
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getIncludeBaseInRange());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getBase(), 0.01D);
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getRowCount());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getIgnoreZeroValues());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getColumnCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getMinimumBarLength(), 0.01D);
// // Unstable assertion: assertEquals(12.0, stackedBarRenderer3D0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.isDrawBarOutline());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getRenderAsPercentages());
// // Unstable assertion: assertEquals(1.0, stackedBarRenderer3D0.getMaximumBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0.2, stackedBarRenderer3D0.getItemMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(1, stackedBarRenderer3D0.getPassCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getUpperClip(), 0.01D);
// // Unstable assertion: assertEquals(2.0, stackedBarRenderer3D0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getLowerClip(), 0.01D);
// // Unstable assertion: assertEquals(8.0, stackedBarRenderer3D0.getYOffset(), 0.01D);
// // Unstable assertion: assertNotNull(stackedBarRenderer3D0);
Color color0 = (Color)stackedBarRenderer3D0.getBasePaint();
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getIncludeBaseInRange());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getBase(), 0.01D);
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getRowCount());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getIgnoreZeroValues());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getColumnCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getMinimumBarLength(), 0.01D);
// // Unstable assertion: assertEquals(12.0, stackedBarRenderer3D0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.isDrawBarOutline());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getRenderAsPercentages());
// // Unstable assertion: assertEquals(1.0, stackedBarRenderer3D0.getMaximumBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0.2, stackedBarRenderer3D0.getItemMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(1, stackedBarRenderer3D0.getPassCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getUpperClip(), 0.01D);
// // Unstable assertion: assertEquals(2.0, stackedBarRenderer3D0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getLowerClip(), 0.01D);
// // Unstable assertion: assertEquals(8.0, stackedBarRenderer3D0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertNotNull(color0);
ValueMarker valueMarker0 = new ValueMarker((double) int0, (Paint) color0, (Stroke) basicStroke0);
// // Unstable assertion: assertNull(valueMarker0.getLabel());
// // Unstable assertion: assertEquals(0.0, valueMarker0.getValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, valueMarker0.getAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getIncludeBaseInRange());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getBase(), 0.01D);
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getRowCount());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getIgnoreZeroValues());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getColumnCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getMinimumBarLength(), 0.01D);
// // Unstable assertion: assertEquals(12.0, stackedBarRenderer3D0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.isDrawBarOutline());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getRenderAsPercentages());
// // Unstable assertion: assertEquals(1.0, stackedBarRenderer3D0.getMaximumBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0.2, stackedBarRenderer3D0.getItemMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(1, stackedBarRenderer3D0.getPassCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getUpperClip(), 0.01D);
// // Unstable assertion: assertEquals(2.0, stackedBarRenderer3D0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getLowerClip(), 0.01D);
// // Unstable assertion: assertEquals(8.0, stackedBarRenderer3D0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertNotNull(valueMarker0);
boolean boolean0 = combinedDomainXYPlot0.removeDomainMarker((Marker) valueMarker0);
// // Unstable assertion: assertNull(valueMarker0.getLabel());
// // Unstable assertion: assertEquals(0.0, valueMarker0.getValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, valueMarker0.getAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getIncludeBaseInRange());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getBase(), 0.01D);
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getRowCount());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getIgnoreZeroValues());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(0, stackedBarRenderer3D0.getColumnCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getMinimumBarLength(), 0.01D);
// // Unstable assertion: assertEquals(12.0, stackedBarRenderer3D0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.isDrawBarOutline());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getRenderAsPercentages());
// // Unstable assertion: assertEquals(1.0, stackedBarRenderer3D0.getMaximumBarWidth(), 0.01D);
// // Unstable assertion: assertEquals(0.2, stackedBarRenderer3D0.getItemMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(1, stackedBarRenderer3D0.getPassCount());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getUpperClip(), 0.01D);
// // Unstable assertion: assertEquals(2.0, stackedBarRenderer3D0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedBarRenderer3D0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, stackedBarRenderer3D0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(0.0, stackedBarRenderer3D0.getLowerClip(), 0.01D);
// // Unstable assertion: assertEquals(8.0, stackedBarRenderer3D0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertFalse(boolean0);
}
@Test
public void test099() throws Throwable {
String string0 = "Null 'map' argument.";
boolean boolean0 = true;
MinMaxCategoryRenderer minMaxCategoryRenderer0 = new MinMaxCategoryRenderer();
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, minMaxCategoryRenderer0.isDrawLines());
assertEquals(0, minMaxCategoryRenderer0.getColumnCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(2.0, minMaxCategoryRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, minMaxCategoryRenderer0.getBaseCreateEntities());
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(1, minMaxCategoryRenderer0.getPassCount());
assertEquals(false, minMaxCategoryRenderer0.getBaseItemLabelsVisible());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0, minMaxCategoryRenderer0.getRowCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisible());
assertNotNull(minMaxCategoryRenderer0);
Font font0 = minMaxCategoryRenderer0.getBaseItemLabelFont();
assertEquals("SansSerif", font0.getName());
assertEquals(false, font0.isItalic());
assertEquals(10.0F, font0.getSize2D(), 0.01F);
assertEquals(0, font0.getStyle());
assertEquals(false, font0.hasLayoutAttributes());
assertEquals("java.awt.Font[family=SansSerif,name=SansSerif,style=plain,size=10]", font0.toString());
assertEquals(true, font0.isPlain());
assertEquals(false, font0.isTransformed());
assertEquals(10, font0.getSize());
assertEquals(false, font0.isBold());
assertEquals(false, font0.hasUniformLineMetrics());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, minMaxCategoryRenderer0.isDrawLines());
assertEquals(0, minMaxCategoryRenderer0.getColumnCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(2.0, minMaxCategoryRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, minMaxCategoryRenderer0.getBaseCreateEntities());
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(1, minMaxCategoryRenderer0.getPassCount());
assertEquals(false, minMaxCategoryRenderer0.getBaseItemLabelsVisible());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0, minMaxCategoryRenderer0.getRowCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisible());
assertNotNull(font0);
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNotNull(combinedRangeXYPlot0);
JFreeChart jFreeChart0 = new JFreeChart(string0, font0, (Plot) combinedRangeXYPlot0, boolean0);
assertEquals("SansSerif", font0.getName());
assertEquals(false, font0.isItalic());
assertEquals(10.0F, font0.getSize2D(), 0.01F);
assertEquals(0, font0.getStyle());
assertEquals(false, font0.hasLayoutAttributes());
assertEquals("java.awt.Font[family=SansSerif,name=SansSerif,style=plain,size=10]", font0.toString());
assertEquals(true, font0.isPlain());
assertEquals(false, font0.isTransformed());
assertEquals(10, font0.getSize());
assertEquals(false, font0.isBold());
assertEquals(false, font0.hasUniformLineMetrics());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, jFreeChart0.getSubtitleCount());
assertEquals(0.5F, jFreeChart0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, jFreeChart0.isBorderVisible());
assertEquals(true, jFreeChart0.getAntiAlias());
assertEquals(15, jFreeChart0.getBackgroundImageAlignment());
assertEquals(true, jFreeChart0.isNotify());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, minMaxCategoryRenderer0.isDrawLines());
assertEquals(0, minMaxCategoryRenderer0.getColumnCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(2.0, minMaxCategoryRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, minMaxCategoryRenderer0.getBaseCreateEntities());
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(1, minMaxCategoryRenderer0.getPassCount());
assertEquals(false, minMaxCategoryRenderer0.getBaseItemLabelsVisible());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0, minMaxCategoryRenderer0.getRowCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisible());
assertNotNull(jFreeChart0);
ChartPanel chartPanel0 = new ChartPanel(jFreeChart0, boolean0);
assertEquals("SansSerif", font0.getName());
assertEquals(false, font0.isItalic());
assertEquals(10.0F, font0.getSize2D(), 0.01F);
assertEquals(0, font0.getStyle());
assertEquals(false, font0.hasLayoutAttributes());
assertEquals("java.awt.Font[family=SansSerif,name=SansSerif,style=plain,size=10]", font0.toString());
assertEquals(true, font0.isPlain());
assertEquals(false, font0.isTransformed());
assertEquals(10, font0.getSize());
assertEquals(false, font0.isBold());
assertEquals(false, font0.hasUniformLineMetrics());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(300, chartPanel0.getMinimumDrawWidth());
assertEquals(0.5, chartPanel0.getZoomInFactor(), 0.01D);
assertEquals(false, chartPanel0.isLightweight());
assertEquals(true, chartPanel0.isEnabled());
assertEquals(false, chartPanel0.getIgnoreRepaint());
assertEquals(false, chartPanel0.isValid());
assertEquals(750, chartPanel0.getInitialDelay());
assertEquals(true, chartPanel0.isEnforceFileExtensions());
assertEquals(true, chartPanel0.isPreferredSizeSet());
assertEquals(false, chartPanel0.isMaximumSizeSet());
assertEquals(true, chartPanel0.isBackgroundSet());
assertEquals(true, chartPanel0.isVisible());
assertEquals(false, chartPanel0.isFocusTraversalPolicyProvider());
assertEquals(true, chartPanel0.isRangeZoomable());
assertEquals(200, chartPanel0.getMinimumDrawHeight());
assertEquals(10, chartPanel0.getZoomTriggerDistance());
assertEquals(true, chartPanel0.getFocusTraversalKeysEnabled());
assertEquals(true, chartPanel0.isDomainZoomable());
assertEquals(0, chartPanel0.countComponents());
assertEquals(600, chartPanel0.getMaximumDrawHeight());
assertEquals(800, chartPanel0.getMaximumDrawWidth());
assertEquals(false, chartPanel0.isFocusTraversalPolicySet());
assertEquals(true, chartPanel0.isForegroundSet());
assertEquals(false, chartPanel0.getFillZoomRectangle());
assertEquals(false, chartPanel0.isMinimumSizeSet());
assertEquals(false, chartPanel0.getRefreshBuffer());
assertEquals(4000, chartPanel0.getDismissDelay());
assertEquals(false, chartPanel0.isFocusCycleRoot());
assertEquals(false, chartPanel0.isDisplayable());
assertEquals(0, chartPanel0.getComponentCount());
assertEquals(false, chartPanel0.getHorizontalAxisTrace());
assertEquals(false, chartPanel0.getZoomAroundAnchor());
assertEquals(2.0, chartPanel0.getZoomOutFactor(), 0.01D);
assertEquals(false, chartPanel0.getVerticalAxisTrace());
assertEquals(false, chartPanel0.isShowing());
assertEquals(0.0, chartPanel0.getScaleY(), 0.01D);
assertEquals(true, chartPanel0.isFontSet());
assertEquals(500, chartPanel0.getReshowDelay());
assertEquals(false, chartPanel0.isCursorSet());
assertEquals(0.0, chartPanel0.getScaleX(), 0.01D);
assertEquals(1, jFreeChart0.getSubtitleCount());
assertEquals(0.5F, jFreeChart0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, jFreeChart0.isBorderVisible());
assertEquals(true, jFreeChart0.getAntiAlias());
assertEquals(15, jFreeChart0.getBackgroundImageAlignment());
assertEquals(true, jFreeChart0.isNotify());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, minMaxCategoryRenderer0.isDrawLines());
assertEquals(0, minMaxCategoryRenderer0.getColumnCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(2.0, minMaxCategoryRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, minMaxCategoryRenderer0.getBaseCreateEntities());
assertEquals(true, minMaxCategoryRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(1, minMaxCategoryRenderer0.getPassCount());
assertEquals(false, minMaxCategoryRenderer0.getBaseItemLabelsVisible());
assertEquals(false, minMaxCategoryRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0, minMaxCategoryRenderer0.getRowCount());
assertEquals(true, minMaxCategoryRenderer0.getBaseSeriesVisible());
assertNotNull(chartPanel0);
}
@Test
public void test100() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNotNull(combinedRangeXYPlot0);
LegendItemCollection legendItemCollection0 = combinedRangeXYPlot0.getLegendItems();
assertEquals(0, legendItemCollection0.getItemCount());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNotNull(legendItemCollection0);
}
@Test
public void test101() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = true;
StackedAreaRenderer stackedAreaRenderer0 = new StackedAreaRenderer(boolean0);
// // Unstable assertion: assertEquals(2.0, stackedAreaRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(2, stackedAreaRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(0, stackedAreaRenderer0.getColumnCount());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(0, stackedAreaRenderer0.getRowCount());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getRenderAsPercentages());
// // Unstable assertion: assertNotNull(stackedAreaRenderer0);
LegendItemCollection legendItemCollection0 = stackedAreaRenderer0.getLegendItems();
// // Unstable assertion: assertEquals(0, legendItemCollection0.getItemCount());
// // Unstable assertion: assertEquals(2.0, stackedAreaRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(2, stackedAreaRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(0, stackedAreaRenderer0.getColumnCount());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(0, stackedAreaRenderer0.getRowCount());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getRenderAsPercentages());
// // Unstable assertion: assertNotNull(legendItemCollection0);
combinedDomainXYPlot0.setFixedLegendItems(legendItemCollection0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(0, legendItemCollection0.getItemCount());
// // Unstable assertion: assertEquals(2.0, stackedAreaRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(2, stackedAreaRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(0, stackedAreaRenderer0.getColumnCount());
// // Unstable assertion: assertEquals(false, stackedAreaRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(0, stackedAreaRenderer0.getRowCount());
// // Unstable assertion: assertEquals(true, stackedAreaRenderer0.getRenderAsPercentages());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
}
@Test
public void test102() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertNotNull(combinedDomainXYPlot0);
Color color0 = (Color)combinedDomainXYPlot0.getDomainZeroBaselinePaint();
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0, color0.getGreen());
assertEquals(-16777216, color0.getRGB());
assertEquals("java.awt.Color[r=0,g=0,b=0]", color0.toString());
assertEquals(255, color0.getAlpha());
assertEquals(0, color0.getBlue());
assertEquals(0, color0.getRed());
assertEquals(1, color0.getTransparency());
assertNotNull(color0);
boolean boolean0 = true;
DefaultListCellRenderer.UIResource defaultListCellRenderer_UIResource0 = new DefaultListCellRenderer.UIResource();
assertEquals(false, defaultListCellRenderer_UIResource0.isCursorSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicyProvider());
assertEquals(true, defaultListCellRenderer_UIResource0.isVisible());
assertEquals(true, defaultListCellRenderer_UIResource0.isBackgroundSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isValid());
assertEquals(true, defaultListCellRenderer_UIResource0.isForegroundSet());
assertEquals(true, defaultListCellRenderer_UIResource0.isFontSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isMaximumSizeSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isShowing());
assertEquals(0, defaultListCellRenderer_UIResource0.getComponentCount());
assertEquals(true, defaultListCellRenderer_UIResource0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isDisplayable());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusCycleRoot());
assertEquals(false, defaultListCellRenderer_UIResource0.isLightweight());
assertEquals(true, defaultListCellRenderer_UIResource0.isEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isMinimumSizeSet());
assertEquals(0, defaultListCellRenderer_UIResource0.countComponents());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicySet());
assertEquals(false, defaultListCellRenderer_UIResource0.getIgnoreRepaint());
assertEquals(false, defaultListCellRenderer_UIResource0.isPreferredSizeSet());
assertNotNull(defaultListCellRenderer_UIResource0);
Rectangle rectangle0 = defaultListCellRenderer_UIResource0.getBounds();
assertEquals(false, defaultListCellRenderer_UIResource0.isCursorSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicyProvider());
assertEquals(true, defaultListCellRenderer_UIResource0.isVisible());
assertEquals(true, defaultListCellRenderer_UIResource0.isBackgroundSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isValid());
assertEquals(true, defaultListCellRenderer_UIResource0.isForegroundSet());
assertEquals(true, defaultListCellRenderer_UIResource0.isFontSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isMaximumSizeSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isShowing());
assertEquals(0, defaultListCellRenderer_UIResource0.getComponentCount());
assertEquals(true, defaultListCellRenderer_UIResource0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isDisplayable());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusCycleRoot());
assertEquals(false, defaultListCellRenderer_UIResource0.isLightweight());
assertEquals(true, defaultListCellRenderer_UIResource0.isEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isMinimumSizeSet());
assertEquals(0, defaultListCellRenderer_UIResource0.countComponents());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicySet());
assertEquals(false, defaultListCellRenderer_UIResource0.getIgnoreRepaint());
assertEquals(false, defaultListCellRenderer_UIResource0.isPreferredSizeSet());
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(true, rectangle0.isEmpty());
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.width);
assertEquals(0, rectangle0.y);
assertEquals(0, rectangle0.height);
assertNotNull(rectangle0);
DeviationRenderer deviationRenderer0 = new DeviationRenderer(boolean0, boolean0);
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, deviationRenderer0.getBaseShapesVisible());
assertEquals(0.5F, deviationRenderer0.getAlpha(), 0.01F);
assertEquals(2.0, deviationRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, deviationRenderer0.getUseFillPaint());
assertEquals(true, deviationRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, deviationRenderer0.getUseOutlinePaint());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, deviationRenderer0.getDrawOutlines());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, deviationRenderer0.getBaseItemLabelsVisible());
assertEquals(true, deviationRenderer0.getBaseSeriesVisible());
assertEquals(true, deviationRenderer0.getBaseShapesFilled());
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, deviationRenderer0.getBaseLinesVisible());
assertEquals(true, deviationRenderer0.getBaseCreateEntities());
assertEquals(3, deviationRenderer0.getPassCount());
assertEquals(3, deviationRenderer0.getDefaultEntityRadius());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, deviationRenderer0.getDrawSeriesLineAsPath());
assertNotNull(deviationRenderer0);
BasicStroke basicStroke0 = (BasicStroke)deviationRenderer0.getBaseStroke();
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, deviationRenderer0.getBaseShapesVisible());
assertEquals(0.5F, deviationRenderer0.getAlpha(), 0.01F);
assertEquals(2.0, deviationRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, deviationRenderer0.getUseFillPaint());
assertEquals(true, deviationRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, deviationRenderer0.getUseOutlinePaint());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, deviationRenderer0.getDrawOutlines());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, deviationRenderer0.getBaseItemLabelsVisible());
assertEquals(true, deviationRenderer0.getBaseSeriesVisible());
assertEquals(true, deviationRenderer0.getBaseShapesFilled());
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, deviationRenderer0.getBaseLinesVisible());
assertEquals(true, deviationRenderer0.getBaseCreateEntities());
assertEquals(3, deviationRenderer0.getPassCount());
assertEquals(3, deviationRenderer0.getDefaultEntityRadius());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, deviationRenderer0.getDrawSeriesLineAsPath());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertNotNull(basicStroke0);
XYShapeAnnotation xYShapeAnnotation0 = new XYShapeAnnotation((Shape) rectangle0, (Stroke) basicStroke0, (Paint) color0, (Paint) color0);
assertEquals(false, defaultListCellRenderer_UIResource0.isCursorSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicyProvider());
assertEquals(true, defaultListCellRenderer_UIResource0.isVisible());
assertEquals(true, defaultListCellRenderer_UIResource0.isBackgroundSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isValid());
assertEquals(true, defaultListCellRenderer_UIResource0.isForegroundSet());
assertEquals(true, defaultListCellRenderer_UIResource0.isFontSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isMaximumSizeSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isShowing());
assertEquals(0, defaultListCellRenderer_UIResource0.getComponentCount());
assertEquals(true, defaultListCellRenderer_UIResource0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isDisplayable());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusCycleRoot());
assertEquals(false, defaultListCellRenderer_UIResource0.isLightweight());
assertEquals(true, defaultListCellRenderer_UIResource0.isEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isMinimumSizeSet());
assertEquals(0, defaultListCellRenderer_UIResource0.countComponents());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicySet());
assertEquals(false, defaultListCellRenderer_UIResource0.getIgnoreRepaint());
assertEquals(false, defaultListCellRenderer_UIResource0.isPreferredSizeSet());
assertNull(xYShapeAnnotation0.getURL());
assertNull(xYShapeAnnotation0.getToolTipText());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, deviationRenderer0.getBaseShapesVisible());
assertEquals(0.5F, deviationRenderer0.getAlpha(), 0.01F);
assertEquals(2.0, deviationRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, deviationRenderer0.getUseFillPaint());
assertEquals(true, deviationRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, deviationRenderer0.getUseOutlinePaint());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, deviationRenderer0.getDrawOutlines());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, deviationRenderer0.getBaseItemLabelsVisible());
assertEquals(true, deviationRenderer0.getBaseSeriesVisible());
assertEquals(true, deviationRenderer0.getBaseShapesFilled());
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, deviationRenderer0.getBaseLinesVisible());
assertEquals(true, deviationRenderer0.getBaseCreateEntities());
assertEquals(3, deviationRenderer0.getPassCount());
assertEquals(3, deviationRenderer0.getDefaultEntityRadius());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, deviationRenderer0.getDrawSeriesLineAsPath());
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(true, rectangle0.isEmpty());
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0, color0.getGreen());
assertEquals(-16777216, color0.getRGB());
assertEquals("java.awt.Color[r=0,g=0,b=0]", color0.toString());
assertEquals(255, color0.getAlpha());
assertEquals(0, color0.getBlue());
assertEquals(0, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.width);
assertEquals(0, rectangle0.y);
assertEquals(0, rectangle0.height);
assertNotNull(xYShapeAnnotation0);
boolean boolean1 = combinedDomainXYPlot0.removeAnnotation((XYAnnotation) xYShapeAnnotation0);
assertEquals(false, defaultListCellRenderer_UIResource0.isCursorSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicyProvider());
assertEquals(true, defaultListCellRenderer_UIResource0.isVisible());
assertEquals(true, defaultListCellRenderer_UIResource0.isBackgroundSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isValid());
assertEquals(true, defaultListCellRenderer_UIResource0.isForegroundSet());
assertEquals(true, defaultListCellRenderer_UIResource0.isFontSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isMaximumSizeSet());
assertEquals(false, defaultListCellRenderer_UIResource0.isShowing());
assertEquals(0, defaultListCellRenderer_UIResource0.getComponentCount());
assertEquals(true, defaultListCellRenderer_UIResource0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isDisplayable());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusCycleRoot());
assertEquals(false, defaultListCellRenderer_UIResource0.isLightweight());
assertEquals(true, defaultListCellRenderer_UIResource0.isEnabled());
assertEquals(false, defaultListCellRenderer_UIResource0.isMinimumSizeSet());
assertEquals(0, defaultListCellRenderer_UIResource0.countComponents());
assertEquals(false, defaultListCellRenderer_UIResource0.isFocusTraversalPolicySet());
assertEquals(false, defaultListCellRenderer_UIResource0.getIgnoreRepaint());
assertEquals(false, defaultListCellRenderer_UIResource0.isPreferredSizeSet());
assertNull(xYShapeAnnotation0.getURL());
assertNull(xYShapeAnnotation0.getToolTipText());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, deviationRenderer0.getBaseShapesVisible());
assertEquals(0.5F, deviationRenderer0.getAlpha(), 0.01F);
assertEquals(2.0, deviationRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, deviationRenderer0.getUseFillPaint());
assertEquals(true, deviationRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, deviationRenderer0.getUseOutlinePaint());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, deviationRenderer0.getDrawOutlines());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, deviationRenderer0.getBaseItemLabelsVisible());
assertEquals(true, deviationRenderer0.getBaseSeriesVisible());
assertEquals(true, deviationRenderer0.getBaseShapesFilled());
assertEquals(true, deviationRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, deviationRenderer0.getBaseLinesVisible());
assertEquals(true, deviationRenderer0.getBaseCreateEntities());
assertEquals(3, deviationRenderer0.getPassCount());
assertEquals(3, deviationRenderer0.getDefaultEntityRadius());
assertEquals(false, deviationRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, deviationRenderer0.getDrawSeriesLineAsPath());
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(true, rectangle0.isEmpty());
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0, color0.getGreen());
assertEquals(-16777216, color0.getRGB());
assertEquals("java.awt.Color[r=0,g=0,b=0]", color0.toString());
assertEquals(255, color0.getAlpha());
assertEquals(0, color0.getBlue());
assertEquals(0, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertFalse(boolean1 == boolean0);
assertFalse(boolean0 == boolean1);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.width);
assertEquals(0, rectangle0.y);
assertEquals(0, rectangle0.height);
assertFalse(boolean1);
}
@Test
public void test103() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
int int0 = combinedRangeXYPlot0.getDomainAxisCount();
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, int0);
}
@Test
public void test104() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertNotNull(combinedDomainXYPlot0);
double double0 = 3008.4489574;
YIntervalRenderer yIntervalRenderer0 = new YIntervalRenderer();
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(false, yIntervalRenderer0.getBaseItemLabelsVisible());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, yIntervalRenderer0.getBaseCreateEntities());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesShape());
assertEquals(3, yIntervalRenderer0.getDefaultEntityRadius());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisible());
assertEquals(1, yIntervalRenderer0.getPassCount());
assertEquals(2.0, yIntervalRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertNotNull(yIntervalRenderer0);
int int0 = 3;
Color color0 = (Color)yIntervalRenderer0.lookupSeriesOutlinePaint(int0);
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(false, yIntervalRenderer0.getBaseItemLabelsVisible());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, yIntervalRenderer0.getBaseCreateEntities());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesShape());
assertEquals(3, yIntervalRenderer0.getDefaultEntityRadius());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisible());
assertEquals(1, yIntervalRenderer0.getPassCount());
assertEquals(2.0, yIntervalRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(128, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(128, color0.getGreen());
assertEquals(-8355712, color0.getRGB());
assertEquals(255, color0.getAlpha());
assertEquals(128, color0.getBlue());
assertEquals("java.awt.Color[r=128,g=128,b=128]", color0.toString());
assertNotNull(color0);
StatisticalBarRenderer statisticalBarRenderer0 = new StatisticalBarRenderer();
assertEquals(2.0, statisticalBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisible());
assertEquals(false, statisticalBarRenderer0.isDrawBarOutline());
assertEquals(true, statisticalBarRenderer0.getIncludeBaseInRange());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, statisticalBarRenderer0.getBaseCreateEntities());
assertEquals(0.2, statisticalBarRenderer0.getItemMargin(), 0.01D);
assertEquals(1.0, statisticalBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(0.0, statisticalBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0.0, statisticalBarRenderer0.getUpperClip(), 0.01D);
assertEquals(0, statisticalBarRenderer0.getRowCount());
assertEquals(0.0, statisticalBarRenderer0.getLowerClip(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getBaseItemLabelsVisible());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0.0, statisticalBarRenderer0.getBase(), 0.01D);
assertEquals(1, statisticalBarRenderer0.getPassCount());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(0, statisticalBarRenderer0.getColumnCount());
assertNotNull(statisticalBarRenderer0);
BasicStroke basicStroke0 = (BasicStroke)statisticalBarRenderer0.getItemStroke(int0, int0);
assertEquals(2.0, statisticalBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisible());
assertEquals(false, statisticalBarRenderer0.isDrawBarOutline());
assertEquals(true, statisticalBarRenderer0.getIncludeBaseInRange());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, statisticalBarRenderer0.getBaseCreateEntities());
assertEquals(0.2, statisticalBarRenderer0.getItemMargin(), 0.01D);
assertEquals(1.0, statisticalBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(0.0, statisticalBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0.0, statisticalBarRenderer0.getUpperClip(), 0.01D);
assertEquals(0, statisticalBarRenderer0.getRowCount());
assertEquals(0.0, statisticalBarRenderer0.getLowerClip(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getBaseItemLabelsVisible());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0.0, statisticalBarRenderer0.getBase(), 0.01D);
assertEquals(1, statisticalBarRenderer0.getPassCount());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(0, statisticalBarRenderer0.getColumnCount());
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertNotNull(basicStroke0);
float float0 = 0.8F;
ValueMarker valueMarker0 = new ValueMarker(double0, (Paint) color0, (Stroke) basicStroke0, (Paint) color0, (Stroke) basicStroke0, float0);
assertEquals(2.0, statisticalBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisible());
assertEquals(false, statisticalBarRenderer0.isDrawBarOutline());
assertEquals(true, statisticalBarRenderer0.getIncludeBaseInRange());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, statisticalBarRenderer0.getBaseCreateEntities());
assertEquals(0.2, statisticalBarRenderer0.getItemMargin(), 0.01D);
assertEquals(1.0, statisticalBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(0.0, statisticalBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0.0, statisticalBarRenderer0.getUpperClip(), 0.01D);
assertEquals(0, statisticalBarRenderer0.getRowCount());
assertEquals(0.0, statisticalBarRenderer0.getLowerClip(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getBaseItemLabelsVisible());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0.0, statisticalBarRenderer0.getBase(), 0.01D);
assertEquals(1, statisticalBarRenderer0.getPassCount());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(0, statisticalBarRenderer0.getColumnCount());
assertEquals(3008.4489574, valueMarker0.getValue(), 0.01D);
assertNull(valueMarker0.getLabel());
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(false, yIntervalRenderer0.getBaseItemLabelsVisible());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, yIntervalRenderer0.getBaseCreateEntities());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesShape());
assertEquals(3, yIntervalRenderer0.getDefaultEntityRadius());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisible());
assertEquals(1, yIntervalRenderer0.getPassCount());
assertEquals(2.0, yIntervalRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(128, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(128, color0.getGreen());
assertEquals(-8355712, color0.getRGB());
assertEquals(255, color0.getAlpha());
assertEquals(128, color0.getBlue());
assertEquals("java.awt.Color[r=128,g=128,b=128]", color0.toString());
assertNotNull(valueMarker0);
Layer layer0 = Layer.BACKGROUND;
assertEquals("Layer.BACKGROUND", layer0.toString());
assertNotNull(layer0);
boolean boolean0 = combinedDomainXYPlot0.removeDomainMarker((Marker) valueMarker0, layer0);
assertEquals(2.0, statisticalBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisible());
assertEquals(false, statisticalBarRenderer0.isDrawBarOutline());
assertEquals(true, statisticalBarRenderer0.getIncludeBaseInRange());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, statisticalBarRenderer0.getBaseCreateEntities());
assertEquals(0.2, statisticalBarRenderer0.getItemMargin(), 0.01D);
assertEquals(1.0, statisticalBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(0.0, statisticalBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(0.0, statisticalBarRenderer0.getUpperClip(), 0.01D);
assertEquals(0, statisticalBarRenderer0.getRowCount());
assertEquals(0.0, statisticalBarRenderer0.getLowerClip(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getBaseItemLabelsVisible());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0.0, statisticalBarRenderer0.getBase(), 0.01D);
assertEquals(1, statisticalBarRenderer0.getPassCount());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(0, statisticalBarRenderer0.getColumnCount());
assertEquals(3008.4489574, valueMarker0.getValue(), 0.01D);
assertNull(valueMarker0.getLabel());
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(false, yIntervalRenderer0.getBaseItemLabelsVisible());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, yIntervalRenderer0.getBaseCreateEntities());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, yIntervalRenderer0.getAutoPopulateSeriesShape());
assertEquals(3, yIntervalRenderer0.getDefaultEntityRadius());
assertEquals(false, yIntervalRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(true, yIntervalRenderer0.getBaseSeriesVisible());
assertEquals(1, yIntervalRenderer0.getPassCount());
assertEquals(2.0, yIntervalRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0, basicStroke0.getLineJoin());
assertEquals(2, basicStroke0.getEndCap());
assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(128, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(128, color0.getGreen());
assertEquals(-8355712, color0.getRGB());
assertEquals(255, color0.getAlpha());
assertEquals(128, color0.getBlue());
assertEquals("java.awt.Color[r=128,g=128,b=128]", color0.toString());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals("Layer.BACKGROUND", layer0.toString());
assertFalse(boolean0);
}
@Test
public void test105() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertNotNull(dateAxis0);
int int0 = 0;
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot();
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertNotNull(combinedRangeCategoryPlot0);
AxisLocation axisLocation0 = combinedRangeCategoryPlot0.getRangeAxisLocation(int0);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals("AxisLocation.TOP_OR_LEFT", axisLocation0.toString());
// // Unstable assertion: assertNotNull(axisLocation0);
combinedDomainXYPlot0.setRangeAxisLocation(axisLocation0);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(0, combinedRangeCategoryPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
// // Unstable assertion: assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals("AxisLocation.TOP_OR_LEFT", axisLocation0.toString());
}
@Test
public void test106() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, xYPlot0.getWeight());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(xYPlot0);
String string0 = "<qV";
JFreeChart jFreeChart0 = new JFreeChart(string0, (Plot) xYPlot0);
assertEquals(15, jFreeChart0.getBackgroundImageAlignment());
assertEquals(true, jFreeChart0.getAntiAlias());
assertEquals(false, jFreeChart0.isBorderVisible());
assertEquals(1, jFreeChart0.getSubtitleCount());
assertEquals(true, jFreeChart0.isNotify());
assertEquals(0.5F, jFreeChart0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, xYPlot0.getWeight());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(xYPlot0.getNoDataMessage());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertNotNull(jFreeChart0);
int int0 = 53;
// Undeclared exception!
try {
BufferedImage bufferedImage0 = jFreeChart0.createBufferedImage(int0, int0);
fail("Expecting exception: NullPointerException");
} catch(NullPointerException e) {
//
// no message in exception (getMessage() returned null)
//
}
}
@Test
public void test107() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(xYPlot0);
BasicStroke basicStroke0 = (BasicStroke)xYPlot0.getRangeCrosshairStroke();
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertNotNull(basicStroke0);
}
@Test
public void test108() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
ValueAxis valueAxis0 = combinedRangeXYPlot0.getDomainAxisForDataset(int0);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(valueAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot(valueAxis0);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = combinedDomainXYPlot0.isRangeZeroBaselineVisible();
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertFalse(boolean0);
}
@Test
public void test109() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNotNull(combinedRangeXYPlot0);
Color color0 = (Color)combinedRangeXYPlot0.getRangeCrosshairPaint();
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(255, color0.getBlue());
assertEquals(1, color0.getTransparency());
assertEquals(0, color0.getGreen());
assertEquals(255, color0.getAlpha());
assertEquals(-16776961, color0.getRGB());
assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
assertEquals(0, color0.getRed());
assertNotNull(color0);
}
@Test
public void test110() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNotNull(combinedDomainXYPlot0);
FastScatterPlot fastScatterPlot0 = new FastScatterPlot();
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertNotNull(fastScatterPlot0);
NumberAxis numberAxis0 = (NumberAxis)fastScatterPlot0.getRangeAxis();
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isInverted());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(true, numberAxis0.isVisible());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertNotNull(numberAxis0);
int int0 = combinedDomainXYPlot0.getDomainAxisIndex((ValueAxis) numberAxis0);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isInverted());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(true, numberAxis0.isVisible());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals((-1), int0);
StatisticalBarRenderer statisticalBarRenderer0 = new StatisticalBarRenderer();
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(0.0, statisticalBarRenderer0.getUpperClip(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getIncludeBaseInRange());
assertEquals(true, statisticalBarRenderer0.getBaseCreateEntities());
assertEquals(0.2, statisticalBarRenderer0.getItemMargin(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(0, statisticalBarRenderer0.getRowCount());
assertEquals(false, statisticalBarRenderer0.getBaseItemLabelsVisible());
assertEquals(2.0, statisticalBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0.0, statisticalBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, statisticalBarRenderer0.isDrawBarOutline());
assertEquals(0, statisticalBarRenderer0.getColumnCount());
assertEquals(1.0, statisticalBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(1, statisticalBarRenderer0.getPassCount());
assertEquals(0.0, statisticalBarRenderer0.getBase(), 0.01D);
assertEquals(0.0, statisticalBarRenderer0.getLowerClip(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisible());
assertNotNull(statisticalBarRenderer0);
Paint paint0 = statisticalBarRenderer0.getSeriesItemLabelPaint(int0);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(0.0, statisticalBarRenderer0.getUpperClip(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getIncludeBaseInRange());
assertEquals(true, statisticalBarRenderer0.getBaseCreateEntities());
assertEquals(0.2, statisticalBarRenderer0.getItemMargin(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(0, statisticalBarRenderer0.getRowCount());
assertEquals(false, statisticalBarRenderer0.getBaseItemLabelsVisible());
assertEquals(2.0, statisticalBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0.0, statisticalBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, statisticalBarRenderer0.isDrawBarOutline());
assertEquals(0, statisticalBarRenderer0.getColumnCount());
assertEquals(1.0, statisticalBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(1, statisticalBarRenderer0.getPassCount());
assertEquals(0.0, statisticalBarRenderer0.getBase(), 0.01D);
assertEquals(0.0, statisticalBarRenderer0.getLowerClip(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisible());
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isInverted());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(true, numberAxis0.isVisible());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertNull(paint0);
combinedDomainXYPlot0.setDomainTickBandPaint(paint0);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesShape());
assertEquals(0.0, statisticalBarRenderer0.getUpperClip(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getIncludeBaseInRange());
assertEquals(true, statisticalBarRenderer0.getBaseCreateEntities());
assertEquals(0.2, statisticalBarRenderer0.getItemMargin(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(0, statisticalBarRenderer0.getRowCount());
assertEquals(false, statisticalBarRenderer0.getBaseItemLabelsVisible());
assertEquals(2.0, statisticalBarRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, statisticalBarRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(0.0, statisticalBarRenderer0.getMinimumBarLength(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, statisticalBarRenderer0.isDrawBarOutline());
assertEquals(0, statisticalBarRenderer0.getColumnCount());
assertEquals(1.0, statisticalBarRenderer0.getMaximumBarWidth(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(1, statisticalBarRenderer0.getPassCount());
assertEquals(0.0, statisticalBarRenderer0.getBase(), 0.01D);
assertEquals(0.0, statisticalBarRenderer0.getLowerClip(), 0.01D);
assertEquals(false, statisticalBarRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, statisticalBarRenderer0.getBaseSeriesVisible());
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(false, numberAxis0.isInverted());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(true, numberAxis0.isVisible());
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertNull(numberAxis0.getLabelToolTip());
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
}
@Test
public void test111() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
SeriesRenderingOrder seriesRenderingOrder0 = combinedRangeXYPlot0.getSeriesRenderingOrder();
assertEquals("SeriesRenderingOrder.REVERSE", seriesRenderingOrder0.toString());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(seriesRenderingOrder0);
}
@Test
public void test112() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNotNull(combinedRangeXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedRangeXYPlot0.getDomainCrosshairStroke();
assertEquals(0, basicStroke0.getEndCap());
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNotNull(basicStroke0);
}
@Test
public void test113() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNotNull(combinedRangeXYPlot0);
Point2D.Double point2D_Double0 = (Point2D.Double)combinedRangeXYPlot0.getQuadrantOrigin();
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, point2D_Double0.y, 0.01D);
assertEquals(0.0, point2D_Double0.x, 0.01D);
assertNotNull(point2D_Double0);
}
@Test
public void test114() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
int int0 = 0;
XYPlot xYPlot0 = new XYPlot();
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertNotNull(xYPlot0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertNotNull(dateAxis0);
BasicStroke basicStroke0 = (BasicStroke)dateAxis0.getTickMarkStroke();
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertNotNull(basicStroke0);
XYLine3DRenderer xYLine3DRenderer0 = new XYLine3DRenderer();
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getDrawSeriesLineAsPath());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseFillPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseOutlinePaint());
// // Unstable assertion: assertEquals(2.0, xYLine3DRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseLinesVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getDrawOutlines());
// // Unstable assertion: assertEquals(12.0, xYLine3DRenderer0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(8.0, xYLine3DRenderer0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesFilled());
// // Unstable assertion: assertNotNull(xYLine3DRenderer0);
Color color0 = (Color)xYLine3DRenderer0.getItemPaint(int0, int0);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getDrawSeriesLineAsPath());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseFillPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseOutlinePaint());
// // Unstable assertion: assertEquals(2.0, xYLine3DRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseLinesVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getDrawOutlines());
// // Unstable assertion: assertEquals(12.0, xYLine3DRenderer0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(8.0, xYLine3DRenderer0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesFilled());
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertNotNull(color0);
CategoryMarker categoryMarker0 = new CategoryMarker((Comparable) int0, (Paint) color0, (Stroke) basicStroke0, (Paint) color0, (Stroke) basicStroke0, (float) int0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getDrawSeriesLineAsPath());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseFillPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseOutlinePaint());
// // Unstable assertion: assertEquals(2.0, xYLine3DRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseLinesVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getDrawOutlines());
// // Unstable assertion: assertEquals(12.0, xYLine3DRenderer0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(8.0, xYLine3DRenderer0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesFilled());
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(0.0F, categoryMarker0.getAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, categoryMarker0.getDrawAsLine());
// // Unstable assertion: assertNull(categoryMarker0.getLabel());
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertNotNull(categoryMarker0);
xYPlot0.addRangeMarker((Marker) categoryMarker0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getBaseItemLabelsVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getDrawSeriesLineAsPath());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesShape());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getAutoPopulateSeriesPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlineStroke());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseFillPaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesOutlinePaint());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getUseOutlinePaint());
// // Unstable assertion: assertEquals(2.0, xYLine3DRenderer0.getItemLabelAnchorOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisible());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesStroke());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getPassCount());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseLinesVisible());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseCreateEntities());
// // Unstable assertion: assertEquals(3, xYLine3DRenderer0.getDefaultEntityRadius());
// // Unstable assertion: assertEquals(false, xYLine3DRenderer0.getAutoPopulateSeriesFillPaint());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseSeriesVisibleInLegend());
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getDrawOutlines());
// // Unstable assertion: assertEquals(12.0, xYLine3DRenderer0.getXOffset(), 0.01D);
// // Unstable assertion: assertEquals(8.0, xYLine3DRenderer0.getYOffset(), 0.01D);
// // Unstable assertion: assertEquals(true, xYLine3DRenderer0.getBaseShapesFilled());
// // Unstable assertion: assertEquals(10.0F, basicStroke0.getMiterLimit(), 0.01F);
// // Unstable assertion: assertEquals(2, basicStroke0.getEndCap());
// // Unstable assertion: assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
// // Unstable assertion: assertEquals(0, basicStroke0.getLineJoin());
// // Unstable assertion: assertEquals(1.0F, basicStroke0.getLineWidth(), 0.01F);
// // Unstable assertion: assertEquals(true, xYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(15, xYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(1, xYPlot0.getWeight());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertNull(xYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, xYPlot0.isSubplot());
// // Unstable assertion: assertEquals(false, xYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, xYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(0.0F, categoryMarker0.getAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, categoryMarker0.getDrawAsLine());
// // Unstable assertion: assertNull(categoryMarker0.getLabel());
// // Unstable assertion: assertEquals(0, color0.getRed());
// // Unstable assertion: assertEquals(255, color0.getAlpha());
// // Unstable assertion: assertEquals(1, color0.getTransparency());
// // Unstable assertion: assertEquals(0, color0.getGreen());
// // Unstable assertion: assertEquals(-16776961, color0.getRGB());
// // Unstable assertion: assertEquals(255, color0.getBlue());
// // Unstable assertion: assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
}
@Test
public void test115() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertNotNull(combinedDomainXYPlot0);
double double0 = 2353.3;
PlotRenderingInfo plotRenderingInfo0 = null;
DefaultTreeCellRenderer defaultTreeCellRenderer0 = new DefaultTreeCellRenderer();
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertNotNull(defaultTreeCellRenderer0);
Point point0 = defaultTreeCellRenderer0.getLocation();
assertEquals(0.0, point0.getY(), 0.01D);
assertEquals(0.0, point0.getX(), 0.01D);
assertEquals("java.awt.Point[x=0,y=0]", point0.toString());
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(0, point0.x);
assertEquals(0, point0.y);
assertNotNull(point0);
combinedDomainXYPlot0.zoomDomainAxes(double0, plotRenderingInfo0, (Point2D) point0);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(0.0, point0.getY(), 0.01D);
assertEquals(0.0, point0.getX(), 0.01D);
assertEquals("java.awt.Point[x=0,y=0]", point0.toString());
assertEquals(0, defaultTreeCellRenderer0.countComponents());
assertEquals(false, defaultTreeCellRenderer0.isCursorSet());
assertEquals(true, defaultTreeCellRenderer0.getFocusTraversalKeysEnabled());
assertEquals(false, defaultTreeCellRenderer0.isPreferredSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFontSet());
assertEquals(false, defaultTreeCellRenderer0.isMinimumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isDisplayable());
assertEquals(true, defaultTreeCellRenderer0.isEnabled());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicySet());
assertEquals(false, defaultTreeCellRenderer0.isLightweight());
assertEquals(false, defaultTreeCellRenderer0.isValid());
assertEquals(true, defaultTreeCellRenderer0.isVisible());
assertEquals(0, defaultTreeCellRenderer0.getComponentCount());
assertEquals(false, defaultTreeCellRenderer0.isFocusTraversalPolicyProvider());
assertEquals(false, defaultTreeCellRenderer0.isShowing());
assertEquals(true, defaultTreeCellRenderer0.isForegroundSet());
assertEquals(false, defaultTreeCellRenderer0.isBackgroundSet());
assertEquals(false, defaultTreeCellRenderer0.isMaximumSizeSet());
assertEquals(false, defaultTreeCellRenderer0.isFocusCycleRoot());
assertEquals(false, defaultTreeCellRenderer0.getIgnoreRepaint());
assertEquals(0, point0.x);
assertEquals(0, point0.y);
}
@Test
public void test116() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNotNull(combinedRangeXYPlot0);
Paint paint0 = combinedRangeXYPlot0.getRangeTickBandPaint();
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertNull(paint0);
}
@Test
public void test117() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
double double0 = (-2185.469518654);
FastScatterPlot fastScatterPlot0 = new FastScatterPlot();
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertNotNull(fastScatterPlot0);
Color color0 = (Color)combinedDomainXYPlot0.getRangeGridlinePaint();
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(255, color0.getGreen());
assertEquals(-1, color0.getRGB());
assertEquals(255, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(255, color0.getAlpha());
assertEquals(255, color0.getBlue());
assertEquals("java.awt.Color[r=255,g=255,b=255]", color0.toString());
assertNotNull(color0);
NumberAxis numberAxis0 = (NumberAxis)fastScatterPlot0.getRangeAxis();
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertNotNull(numberAxis0);
int int0 = 0;
CombinedRangeCategoryPlot combinedRangeCategoryPlot0 = new CombinedRangeCategoryPlot((ValueAxis) numberAxis0);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertNotNull(combinedRangeCategoryPlot0);
CategoryAxis categoryAxis0 = combinedRangeCategoryPlot0.getDomainAxisForDataset(int0);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertNull(categoryAxis0);
CombinedDomainCategoryPlot combinedDomainCategoryPlot0 = new CombinedDomainCategoryPlot(categoryAxis0);
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertNotNull(combinedDomainCategoryPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedDomainCategoryPlot0.getDomainGridlineStroke();
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(0, basicStroke0.getEndCap());
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertNotNull(basicStroke0);
CategoryMarker categoryMarker0 = new CategoryMarker((Comparable) double0, (Paint) color0, (Stroke) basicStroke0);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertNull(categoryMarker0.getLabel());
assertEquals(1.0F, categoryMarker0.getAlpha(), 0.01F);
assertEquals(false, categoryMarker0.getDrawAsLine());
assertEquals(255, color0.getGreen());
assertEquals(-1, color0.getRGB());
assertEquals(255, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(255, color0.getAlpha());
assertEquals(255, color0.getBlue());
assertEquals("java.awt.Color[r=255,g=255,b=255]", color0.toString());
assertEquals(0, basicStroke0.getEndCap());
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
assertNotNull(categoryMarker0);
Layer layer0 = Layer.BACKGROUND;
assertEquals("Layer.BACKGROUND", layer0.toString());
assertNotNull(layer0);
combinedDomainXYPlot0.addRangeMarker(int0, (Marker) categoryMarker0, layer0);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals("Layer.BACKGROUND", layer0.toString());
assertNull(categoryMarker0.getLabel());
assertEquals(1.0F, categoryMarker0.getAlpha(), 0.01F);
assertEquals(false, categoryMarker0.getDrawAsLine());
assertEquals(255, color0.getGreen());
assertEquals(-1, color0.getRGB());
assertEquals(255, color0.getRed());
assertEquals(1, color0.getTransparency());
assertEquals(255, color0.getAlpha());
assertEquals(255, color0.getBlue());
assertEquals("java.awt.Color[r=255,g=255,b=255]", color0.toString());
assertEquals(0, basicStroke0.getEndCap());
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(0.0F, numberAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAxisLineVisible());
assertEquals(true, numberAxis0.isAutoTickUnitSelection());
assertEquals(0.0, numberAxis0.getLowerBound(), 0.01D);
assertEquals(2.0F, numberAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(true, numberAxis0.isAutoRange());
assertEquals(false, numberAxis0.isPositiveArrowVisible());
assertEquals(false, numberAxis0.isVerticalTickLabels());
assertEquals("Y", numberAxis0.getLabel());
assertEquals(false, numberAxis0.isNegativeArrowVisible());
assertEquals(0.0, numberAxis0.getFixedAutoRange(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeIncludesZero());
assertEquals(0.0, numberAxis0.getLabelAngle(), 0.01D);
assertEquals(1.05, numberAxis0.getUpperBound(), 0.01D);
assertEquals(false, numberAxis0.isInverted());
assertEquals(0.05, numberAxis0.getUpperMargin(), 0.01D);
assertEquals(true, numberAxis0.isVisible());
assertEquals(0.0, numberAxis0.getFixedDimension(), 0.01D);
assertEquals(true, numberAxis0.getAutoRangeStickyZero());
assertNull(numberAxis0.getLabelToolTip());
assertEquals(true, numberAxis0.isTickMarksVisible());
assertEquals(true, numberAxis0.isTickLabelsVisible());
assertNull(numberAxis0.getLabelURL());
assertEquals(1.0E-8, numberAxis0.getAutoRangeMinimumSize(), 0.01D);
assertEquals(0.05, numberAxis0.getLowerMargin(), 0.01D);
assertEquals(15, fastScatterPlot0.getBackgroundImageAlignment());
assertEquals(true, fastScatterPlot0.isDomainGridlinesVisible());
assertEquals(false, fastScatterPlot0.isSubplot());
assertEquals(true, fastScatterPlot0.isDomainZoomable());
assertEquals(1.0F, fastScatterPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isRangeGridlinesVisible());
assertEquals(true, fastScatterPlot0.isRangeZoomable());
assertEquals(1.0F, fastScatterPlot0.getBackgroundAlpha(), 0.01F);
assertNull(fastScatterPlot0.getNoDataMessage());
assertEquals(0.5F, fastScatterPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, fastScatterPlot0.isOutlineVisible());
assertEquals(5.0, combinedRangeCategoryPlot0.getGap(), 0.01D);
assertEquals(15, combinedRangeCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeCategoryPlot0.isRangeZoomable());
assertNull(combinedRangeCategoryPlot0.getNoDataMessage());
assertEquals(true, combinedRangeCategoryPlot0.isRangeGridlinesVisible());
assertEquals(0.0, combinedRangeCategoryPlot0.getAnchorValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedRangeCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0.5F, combinedRangeCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeCategoryPlot0.isDomainZoomable());
assertEquals(true, combinedRangeCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedRangeCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeCategoryPlot0.isSubplot());
assertEquals(false, combinedRangeCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0, combinedRangeCategoryPlot0.getWeight());
assertEquals(1.0F, combinedRangeCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeCategoryPlot0.isOutlineVisible());
}
@Test
public void test118() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedDomainXYPlot0);
AxisSpace axisSpace0 = new AxisSpace();
assertEquals(0.0, axisSpace0.getBottom(), 0.01D);
assertEquals(0.0, axisSpace0.getTop(), 0.01D);
assertEquals(0.0, axisSpace0.getRight(), 0.01D);
assertEquals(0.0, axisSpace0.getLeft(), 0.01D);
assertNotNull(axisSpace0);
combinedDomainXYPlot0.setFixedRangeAxisSpace(axisSpace0);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.0, axisSpace0.getBottom(), 0.01D);
assertEquals(0.0, axisSpace0.getTop(), 0.01D);
assertEquals(0.0, axisSpace0.getRight(), 0.01D);
assertEquals(0.0, axisSpace0.getLeft(), 0.01D);
}
@Test
public void test119() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNotNull(combinedDomainXYPlot0);
int int0 = 2796;
AxisLocation axisLocation0 = combinedDomainXYPlot0.getRangeAxisLocation(int0);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals("AxisLocation.TOP_OR_RIGHT", axisLocation0.toString());
assertNotNull(axisLocation0);
}
@Test
public void test120() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNotNull(combinedRangeXYPlot0);
int int0 = 0;
combinedRangeXYPlot0.setRangeCrosshairValue((double) int0);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
}
@Test
public void test121() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertNotNull(combinedDomainXYPlot0);
CombinedDomainXYPlot combinedDomainXYPlot1 = (CombinedDomainXYPlot)combinedDomainXYPlot0.clone();
assertNotSame(combinedDomainXYPlot0, combinedDomainXYPlot1);
assertNotSame(combinedDomainXYPlot1, combinedDomainXYPlot0);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot1.isDomainZeroBaselineVisible());
assertEquals(0.5F, combinedDomainXYPlot1.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot1.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot1.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot1.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot1.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot1.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot1.isDomainGridlinesVisible());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot1.getPlotType());
assertEquals(15, combinedDomainXYPlot1.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot1.isRangeCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot1.getBackgroundAlpha(), 0.01F);
assertEquals(1.0F, combinedDomainXYPlot1.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot1.isRangeZeroBaselineVisible());
assertNull(combinedDomainXYPlot1.getNoDataMessage());
assertEquals(1, combinedDomainXYPlot1.getWeight());
assertEquals(true, combinedDomainXYPlot1.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot1.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot1.isOutlineVisible());
assertEquals(5.0, combinedDomainXYPlot1.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot1.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot1.isSubplot());
assertTrue(combinedDomainXYPlot0.equals((Object)combinedDomainXYPlot1));
assertTrue(combinedDomainXYPlot1.equals((Object)combinedDomainXYPlot0));
assertNotNull(combinedDomainXYPlot1);
}
@Test
public void test122() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(1, xYPlot0.getWeight());
assertNotNull(xYPlot0);
int int0 = (-1152);
xYPlot0.setDomainCrosshairValue((double) int0);
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals((-1152.0), xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, xYPlot0.getWeight());
}
@Test
public void test123() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertNotNull(combinedDomainXYPlot0);
String string0 = "";
double double0 = 3008.4489574;
XYTextAnnotation xYTextAnnotation0 = new XYTextAnnotation(string0, double0, double0);
assertEquals(3008.4489574, xYTextAnnotation0.getY(), 0.01D);
assertEquals(3008.4489574, xYTextAnnotation0.getX(), 0.01D);
assertNull(xYTextAnnotation0.getToolTipText());
assertEquals("", xYTextAnnotation0.getText());
assertNull(xYTextAnnotation0.getURL());
assertEquals(0.0, xYTextAnnotation0.getRotationAngle(), 0.01D);
assertNotNull(xYTextAnnotation0);
combinedDomainXYPlot0.addAnnotation((XYAnnotation) xYTextAnnotation0);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(3008.4489574, xYTextAnnotation0.getY(), 0.01D);
assertEquals(3008.4489574, xYTextAnnotation0.getX(), 0.01D);
assertNull(xYTextAnnotation0.getToolTipText());
assertEquals("", xYTextAnnotation0.getText());
assertNull(xYTextAnnotation0.getURL());
assertEquals(0.0, xYTextAnnotation0.getRotationAngle(), 0.01D);
}
@Test
public void test124() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertNotNull(combinedDomainXYPlot0);
Layer layer0 = Layer.FOREGROUND;
assertEquals("Layer.FOREGROUND", layer0.toString());
assertNotNull(layer0);
Collection collection0 = combinedDomainXYPlot0.getDomainMarkers(layer0);
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals("Layer.FOREGROUND", layer0.toString());
assertNull(collection0);
}
@Test
public void test125() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = true;
combinedDomainXYPlot0.setRangeZeroBaselineVisible(boolean0);
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
}
@Test
public void test126() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNotNull(combinedRangeXYPlot0);
BasicStroke basicStroke0 = (BasicStroke)combinedRangeXYPlot0.getDomainGridlineStroke();
assertEquals(2, basicStroke0.getLineJoin());
assertEquals(0.0F, basicStroke0.getDashPhase(), 0.01F);
assertEquals(0.0F, basicStroke0.getMiterLimit(), 0.01F);
assertEquals(0, basicStroke0.getEndCap());
assertEquals(0.5F, basicStroke0.getLineWidth(), 0.01F);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNotNull(basicStroke0);
}
@Test
public void test127() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertNotNull(xYPlot0);
Paint paint0 = xYPlot0.getDomainTickBandPaint();
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertNull(paint0);
xYPlot0.setRangeTickBandPaint(paint0);
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(false, xYPlot0.isSubplot());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1, xYPlot0.getWeight());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
}
@Test
public void test128() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertNotNull(combinedRangeXYPlot0);
boolean boolean0 = combinedRangeXYPlot0.isDomainCrosshairLockedOnData();
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertTrue(boolean0);
}
@Test
public void test129() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertNotNull(combinedDomainXYPlot0);
double double0 = 1240.29;
ValueMarker valueMarker0 = new ValueMarker(double0);
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertNull(valueMarker0.getLabel());
assertEquals(1240.29, valueMarker0.getValue(), 0.01D);
assertNotNull(valueMarker0);
combinedDomainXYPlot0.addDomainMarker((Marker) valueMarker0);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(0.8F, valueMarker0.getAlpha(), 0.01F);
assertNull(valueMarker0.getLabel());
assertEquals(1240.29, valueMarker0.getValue(), 0.01D);
}
@Test
public void test130() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNotNull(combinedDomainXYPlot0);
XYDataset xYDataset0 = combinedDomainXYPlot0.getDataset();
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertNull(xYDataset0);
combinedDomainXYPlot0.setDataset(xYDataset0);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
}
@Test
public void test131() throws Throwable {
ValueAxis valueAxis0 = null;
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot(valueAxis0);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertNotNull(combinedRangeXYPlot0);
XYDotRenderer xYDotRenderer0 = new XYDotRenderer();
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, xYDotRenderer0.getBaseSeriesVisible());
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(1, xYDotRenderer0.getDotWidth());
assertEquals(2.0, xYDotRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, xYDotRenderer0.getBaseCreateEntities());
assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(1, xYDotRenderer0.getPassCount());
assertEquals(3, xYDotRenderer0.getDefaultEntityRadius());
assertEquals(true, xYDotRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, xYDotRenderer0.getDotHeight());
assertEquals(false, xYDotRenderer0.getBaseItemLabelsVisible());
assertNotNull(xYDotRenderer0);
int int0 = combinedRangeXYPlot0.getIndexOf((XYItemRenderer) xYDotRenderer0);
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, xYDotRenderer0.getBaseSeriesVisible());
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(1, xYDotRenderer0.getDotWidth());
assertEquals(2.0, xYDotRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(true, xYDotRenderer0.getBaseCreateEntities());
assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesPaint());
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(1, xYDotRenderer0.getPassCount());
assertEquals(3, xYDotRenderer0.getDefaultEntityRadius());
assertEquals(true, xYDotRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, xYDotRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, xYDotRenderer0.getAutoPopulateSeriesShape());
assertEquals(1, xYDotRenderer0.getDotHeight());
assertEquals(false, xYDotRenderer0.getBaseItemLabelsVisible());
assertEquals((-1), int0);
}
@Test
public void test132() throws Throwable {
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot();
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertNotNull(combinedDomainXYPlot0);
boolean boolean0 = combinedDomainXYPlot0.isRangeCrosshairLockedOnData();
assertNull(combinedDomainXYPlot0.getNoDataMessage());
assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1, combinedDomainXYPlot0.getWeight());
assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
assertEquals(false, combinedDomainXYPlot0.isSubplot());
assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
assertTrue(boolean0);
}
@Test
public void test133() throws Throwable {
String string0 = "FCMpZWqWN_z'nKG&0";
ZoneInfo zoneInfo0 = (ZoneInfo)RegularTimePeriod.DEFAULT_TIME_ZONE;
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertNotNull(zoneInfo0);
DateAxis dateAxis0 = new DateAxis(string0, (TimeZone) zoneInfo0);
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNotNull(dateAxis0);
CombinedDomainXYPlot combinedDomainXYPlot0 = new CombinedDomainXYPlot((ValueAxis) dateAxis0);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
// // Unstable assertion: assertNotNull(combinedDomainXYPlot0);
AxisSpace axisSpace0 = null;
combinedDomainXYPlot0.setFixedDomainAxisSpace(axisSpace0);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getForegroundAlpha(), 0.01F);
// // Unstable assertion: assertNull(combinedDomainXYPlot0.getNoDataMessage());
// // Unstable assertion: assertEquals(5.0, combinedDomainXYPlot0.getGap(), 0.01D);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainGridlinesVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainCrosshairVisible());
// // Unstable assertion: assertEquals(15, combinedDomainXYPlot0.getBackgroundImageAlignment());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainCrosshairLockedOnData());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isSubplot());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isDomainZoomable());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isDomainZeroBaselineVisible());
// // Unstable assertion: assertEquals(false, combinedDomainXYPlot0.isRangeCrosshairVisible());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getDomainCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(1.0F, combinedDomainXYPlot0.getBackgroundAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeZoomable());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeCrosshairLockedOnData());
// // Unstable assertion: assertEquals(1, combinedDomainXYPlot0.getWeight());
// // Unstable assertion: assertEquals("Combined_Domain_XYPlot", combinedDomainXYPlot0.getPlotType());
// // Unstable assertion: assertEquals(0.0, combinedDomainXYPlot0.getRangeCrosshairValue(), 0.01D);
// // Unstable assertion: assertEquals(0.5F, combinedDomainXYPlot0.getBackgroundImageAlpha(), 0.01F);
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isOutlineVisible());
// // Unstable assertion: assertEquals(true, combinedDomainXYPlot0.isRangeGridlinesVisible());
// // Unstable assertion: assertEquals("</]B*p@", zoneInfo0.getID());
// // Unstable assertion: assertEquals(2.0, dateAxis0.getAutoRangeMinimumSize(), 0.01D);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getUpperMargin(), 0.01D);
// // Unstable assertion: assertEquals(0.0F, dateAxis0.getTickMarkInsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.05, dateAxis0.getLowerMargin(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickMarksVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isVisible());
// // Unstable assertion: assertEquals(1.0, dateAxis0.getUpperBound(), 0.01D);
// // Unstable assertion: assertEquals(false, dateAxis0.isInverted());
// // Unstable assertion: assertEquals(false, dateAxis0.isNegativeArrowVisible());
// // Unstable assertion: assertEquals(false, dateAxis0.isVerticalTickLabels());
// // Unstable assertion: assertEquals(true, dateAxis0.isAxisLineVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoRange());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedDimension(), 0.01D);
// // Unstable assertion: assertEquals(true, dateAxis0.isTickLabelsVisible());
// // Unstable assertion: assertEquals(0.0, dateAxis0.getFixedAutoRange(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelToolTip());
// // Unstable assertion: assertEquals("FCMpZWqWN_z'nKG&0", dateAxis0.getLabel());
// // Unstable assertion: assertEquals(2.0F, dateAxis0.getTickMarkOutsideLength(), 0.01F);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLowerBound(), 0.01D);
// // Unstable assertion: assertEquals(0.0, dateAxis0.getLabelAngle(), 0.01D);
// // Unstable assertion: assertNull(dateAxis0.getLabelURL());
// // Unstable assertion: assertEquals(false, dateAxis0.isPositiveArrowVisible());
// // Unstable assertion: assertEquals(true, dateAxis0.isAutoTickUnitSelection());
}
@Test
public void test134() throws Throwable {
int int0 = 0;
String string0 = "v";
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertNotNull(combinedRangeXYPlot0);
EvoSuiteFile evoSuiteFile0 = null;
boolean boolean0 = FileSystemHandling.appendLineToFile(evoSuiteFile0, string0);
assertFalse(boolean0);
JInternalFrame jInternalFrame0 = new JInternalFrame(string0, boolean0);
assertEquals(false, jInternalFrame0.isPreferredSizeSet());
assertEquals(true, jInternalFrame0.isFocusTraversalPolicySet());
assertEquals(false, jInternalFrame0.isMinimumSizeSet());
assertEquals(false, jInternalFrame0.isVisible());
assertEquals(false, jInternalFrame0.isDisplayable());
assertEquals(true, jInternalFrame0.getFocusTraversalKeysEnabled());
assertEquals(false, jInternalFrame0.isValid());
assertEquals(false, jInternalFrame0.isFocusTraversalPolicyProvider());
assertEquals(2, jInternalFrame0.getComponentCount());
assertEquals(false, jInternalFrame0.getIgnoreRepaint());
assertEquals(true, jInternalFrame0.isBackgroundSet());
assertEquals(false, jInternalFrame0.isMaximumSizeSet());
assertEquals(true, jInternalFrame0.isEnabled());
assertEquals(false, jInternalFrame0.isLightweight());
assertEquals(false, jInternalFrame0.isFontSet());
assertEquals(false, jInternalFrame0.isForegroundSet());
assertEquals(false, jInternalFrame0.isCursorSet());
assertEquals(2, jInternalFrame0.countComponents());
assertEquals(false, jInternalFrame0.isShowing());
assertNotNull(jInternalFrame0);
Rectangle rectangle0 = jInternalFrame0.getVisibleRect();
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(true, rectangle0.isEmpty());
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(false, jInternalFrame0.isPreferredSizeSet());
assertEquals(true, jInternalFrame0.isFocusTraversalPolicySet());
assertEquals(false, jInternalFrame0.isMinimumSizeSet());
assertEquals(false, jInternalFrame0.isVisible());
assertEquals(false, jInternalFrame0.isDisplayable());
assertEquals(true, jInternalFrame0.getFocusTraversalKeysEnabled());
assertEquals(false, jInternalFrame0.isValid());
assertEquals(false, jInternalFrame0.isFocusTraversalPolicyProvider());
assertEquals(2, jInternalFrame0.getComponentCount());
assertEquals(false, jInternalFrame0.getIgnoreRepaint());
assertEquals(true, jInternalFrame0.isBackgroundSet());
assertEquals(false, jInternalFrame0.isMaximumSizeSet());
assertEquals(true, jInternalFrame0.isEnabled());
assertEquals(false, jInternalFrame0.isLightweight());
assertEquals(false, jInternalFrame0.isFontSet());
assertEquals(false, jInternalFrame0.isForegroundSet());
assertEquals(false, jInternalFrame0.isCursorSet());
assertEquals(2, jInternalFrame0.countComponents());
assertEquals(false, jInternalFrame0.isShowing());
assertEquals(0, rectangle0.width);
assertEquals(0, rectangle0.height);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.y);
assertNotNull(rectangle0);
HighLowRenderer highLowRenderer0 = new HighLowRenderer();
assertEquals(true, highLowRenderer0.getDrawCloseTicks());
assertEquals(3, highLowRenderer0.getDefaultEntityRadius());
assertEquals(false, highLowRenderer0.getBaseItemLabelsVisible());
assertEquals(true, highLowRenderer0.getBaseCreateEntities());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, highLowRenderer0.getDrawOpenTicks());
assertEquals(true, highLowRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesShape());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, highLowRenderer0.getBaseSeriesVisible());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, highLowRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1, highLowRenderer0.getPassCount());
assertNotNull(highLowRenderer0);
XYToolTipGenerator xYToolTipGenerator0 = highLowRenderer0.getToolTipGenerator(rectangle0.y, rectangle0.y);
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(true, rectangle0.isEmpty());
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(false, jInternalFrame0.isPreferredSizeSet());
assertEquals(true, jInternalFrame0.isFocusTraversalPolicySet());
assertEquals(false, jInternalFrame0.isMinimumSizeSet());
assertEquals(false, jInternalFrame0.isVisible());
assertEquals(false, jInternalFrame0.isDisplayable());
assertEquals(true, jInternalFrame0.getFocusTraversalKeysEnabled());
assertEquals(false, jInternalFrame0.isValid());
assertEquals(false, jInternalFrame0.isFocusTraversalPolicyProvider());
assertEquals(2, jInternalFrame0.getComponentCount());
assertEquals(false, jInternalFrame0.getIgnoreRepaint());
assertEquals(true, jInternalFrame0.isBackgroundSet());
assertEquals(false, jInternalFrame0.isMaximumSizeSet());
assertEquals(true, jInternalFrame0.isEnabled());
assertEquals(false, jInternalFrame0.isLightweight());
assertEquals(false, jInternalFrame0.isFontSet());
assertEquals(false, jInternalFrame0.isForegroundSet());
assertEquals(false, jInternalFrame0.isCursorSet());
assertEquals(2, jInternalFrame0.countComponents());
assertEquals(false, jInternalFrame0.isShowing());
assertEquals(true, highLowRenderer0.getDrawCloseTicks());
assertEquals(3, highLowRenderer0.getDefaultEntityRadius());
assertEquals(false, highLowRenderer0.getBaseItemLabelsVisible());
assertEquals(true, highLowRenderer0.getBaseCreateEntities());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, highLowRenderer0.getDrawOpenTicks());
assertEquals(true, highLowRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesShape());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, highLowRenderer0.getBaseSeriesVisible());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, highLowRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1, highLowRenderer0.getPassCount());
assertEquals(0, rectangle0.width);
assertEquals(0, rectangle0.height);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.y);
assertNull(xYToolTipGenerator0);
CyclicXYItemRenderer cyclicXYItemRenderer0 = new CyclicXYItemRenderer();
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, cyclicXYItemRenderer0.getBaseCreateEntities());
assertEquals(false, cyclicXYItemRenderer0.getPlotDiscontinuous());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(1.0, cyclicXYItemRenderer0.getGapThreshold(), 0.01D);
assertEquals(true, cyclicXYItemRenderer0.getPlotLines());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisible());
assertEquals(false, cyclicXYItemRenderer0.getBaseItemLabelsVisible());
assertEquals(true, cyclicXYItemRenderer0.getBaseShapesFilled());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, cyclicXYItemRenderer0.getDrawSeriesLineAsPath());
assertEquals(2.0, cyclicXYItemRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, cyclicXYItemRenderer0.getBaseShapesVisible());
assertEquals(1, cyclicXYItemRenderer0.getPassCount());
assertEquals(3, cyclicXYItemRenderer0.getDefaultEntityRadius());
assertEquals(false, cyclicXYItemRenderer0.getPlotImages());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlinePaint());
assertNotNull(cyclicXYItemRenderer0);
XYURLGenerator xYURLGenerator0 = cyclicXYItemRenderer0.getURLGenerator(int0, int0);
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, cyclicXYItemRenderer0.getBaseCreateEntities());
assertEquals(false, cyclicXYItemRenderer0.getPlotDiscontinuous());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(1.0, cyclicXYItemRenderer0.getGapThreshold(), 0.01D);
assertEquals(true, cyclicXYItemRenderer0.getPlotLines());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisible());
assertEquals(false, cyclicXYItemRenderer0.getBaseItemLabelsVisible());
assertEquals(true, cyclicXYItemRenderer0.getBaseShapesFilled());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, cyclicXYItemRenderer0.getDrawSeriesLineAsPath());
assertEquals(2.0, cyclicXYItemRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, cyclicXYItemRenderer0.getBaseShapesVisible());
assertEquals(1, cyclicXYItemRenderer0.getPassCount());
assertEquals(3, cyclicXYItemRenderer0.getDefaultEntityRadius());
assertEquals(false, cyclicXYItemRenderer0.getPlotImages());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlinePaint());
assertNull(xYURLGenerator0);
StackedXYAreaRenderer2 stackedXYAreaRenderer2_0 = new StackedXYAreaRenderer2(xYToolTipGenerator0, xYURLGenerator0);
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, cyclicXYItemRenderer0.getBaseCreateEntities());
assertEquals(false, cyclicXYItemRenderer0.getPlotDiscontinuous());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(1.0, cyclicXYItemRenderer0.getGapThreshold(), 0.01D);
assertEquals(true, cyclicXYItemRenderer0.getPlotLines());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisible());
assertEquals(false, cyclicXYItemRenderer0.getBaseItemLabelsVisible());
assertEquals(true, cyclicXYItemRenderer0.getBaseShapesFilled());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, cyclicXYItemRenderer0.getDrawSeriesLineAsPath());
assertEquals(2.0, cyclicXYItemRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, cyclicXYItemRenderer0.getBaseShapesVisible());
assertEquals(1, cyclicXYItemRenderer0.getPassCount());
assertEquals(3, cyclicXYItemRenderer0.getDefaultEntityRadius());
assertEquals(false, cyclicXYItemRenderer0.getPlotImages());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(true, rectangle0.isEmpty());
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(true, stackedXYAreaRenderer2_0.getRoundXCoordinates());
assertEquals(false, stackedXYAreaRenderer2_0.getBaseItemLabelsVisible());
assertEquals(true, stackedXYAreaRenderer2_0.getBaseCreateEntities());
assertEquals(true, stackedXYAreaRenderer2_0.getAutoPopulateSeriesPaint());
assertEquals(true, stackedXYAreaRenderer2_0.getAutoPopulateSeriesShape());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesStroke());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesFillPaint());
assertEquals(false, stackedXYAreaRenderer2_0.isOutline());
assertEquals(1, stackedXYAreaRenderer2_0.getPassCount());
assertEquals(2.0, stackedXYAreaRenderer2_0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(3, stackedXYAreaRenderer2_0.getDefaultEntityRadius());
assertEquals(true, stackedXYAreaRenderer2_0.getBaseSeriesVisible());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, stackedXYAreaRenderer2_0.getBaseSeriesVisibleInLegend());
assertEquals(false, jInternalFrame0.isPreferredSizeSet());
assertEquals(true, jInternalFrame0.isFocusTraversalPolicySet());
assertEquals(false, jInternalFrame0.isMinimumSizeSet());
assertEquals(false, jInternalFrame0.isVisible());
assertEquals(false, jInternalFrame0.isDisplayable());
assertEquals(true, jInternalFrame0.getFocusTraversalKeysEnabled());
assertEquals(false, jInternalFrame0.isValid());
assertEquals(false, jInternalFrame0.isFocusTraversalPolicyProvider());
assertEquals(2, jInternalFrame0.getComponentCount());
assertEquals(false, jInternalFrame0.getIgnoreRepaint());
assertEquals(true, jInternalFrame0.isBackgroundSet());
assertEquals(false, jInternalFrame0.isMaximumSizeSet());
assertEquals(true, jInternalFrame0.isEnabled());
assertEquals(false, jInternalFrame0.isLightweight());
assertEquals(false, jInternalFrame0.isFontSet());
assertEquals(false, jInternalFrame0.isForegroundSet());
assertEquals(false, jInternalFrame0.isCursorSet());
assertEquals(2, jInternalFrame0.countComponents());
assertEquals(false, jInternalFrame0.isShowing());
assertEquals(true, highLowRenderer0.getDrawCloseTicks());
assertEquals(3, highLowRenderer0.getDefaultEntityRadius());
assertEquals(false, highLowRenderer0.getBaseItemLabelsVisible());
assertEquals(true, highLowRenderer0.getBaseCreateEntities());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, highLowRenderer0.getDrawOpenTicks());
assertEquals(true, highLowRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesShape());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, highLowRenderer0.getBaseSeriesVisible());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, highLowRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1, highLowRenderer0.getPassCount());
assertEquals(0, rectangle0.width);
assertEquals(0, rectangle0.height);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.y);
assertNotNull(stackedXYAreaRenderer2_0);
combinedRangeXYPlot0.setRenderer((XYItemRenderer) stackedXYAreaRenderer2_0);
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesStroke());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(true, cyclicXYItemRenderer0.getBaseCreateEntities());
assertEquals(false, cyclicXYItemRenderer0.getPlotDiscontinuous());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(1.0, cyclicXYItemRenderer0.getGapThreshold(), 0.01D);
assertEquals(true, cyclicXYItemRenderer0.getPlotLines());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisible());
assertEquals(false, cyclicXYItemRenderer0.getBaseItemLabelsVisible());
assertEquals(true, cyclicXYItemRenderer0.getBaseShapesFilled());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, cyclicXYItemRenderer0.getAutoPopulateSeriesShape());
assertEquals(true, cyclicXYItemRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, cyclicXYItemRenderer0.getDrawSeriesLineAsPath());
assertEquals(2.0, cyclicXYItemRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(false, cyclicXYItemRenderer0.getBaseShapesVisible());
assertEquals(1, cyclicXYItemRenderer0.getPassCount());
assertEquals(3, cyclicXYItemRenderer0.getDefaultEntityRadius());
assertEquals(false, cyclicXYItemRenderer0.getPlotImages());
assertEquals(false, cyclicXYItemRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(0.0, rectangle0.getCenterY(), 0.01D);
assertEquals(0.0, rectangle0.getMaxX(), 0.01D);
assertEquals(0.0, rectangle0.getMaxY(), 0.01D);
assertEquals("java.awt.Rectangle[x=0,y=0,width=0,height=0]", rectangle0.toString());
assertEquals(true, rectangle0.isEmpty());
assertEquals(0.0, rectangle0.getCenterX(), 0.01D);
assertEquals(0.0, rectangle0.getWidth(), 0.01D);
assertEquals(0.0, rectangle0.getY(), 0.01D);
assertEquals(0.0, rectangle0.getX(), 0.01D);
assertEquals(0.0, rectangle0.getHeight(), 0.01D);
assertEquals(0.0, rectangle0.getMinY(), 0.01D);
assertEquals(0.0, rectangle0.getMinX(), 0.01D);
assertEquals(true, stackedXYAreaRenderer2_0.getRoundXCoordinates());
assertEquals(false, stackedXYAreaRenderer2_0.getBaseItemLabelsVisible());
assertEquals(true, stackedXYAreaRenderer2_0.getBaseCreateEntities());
assertEquals(true, stackedXYAreaRenderer2_0.getAutoPopulateSeriesPaint());
assertEquals(true, stackedXYAreaRenderer2_0.getAutoPopulateSeriesShape());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesOutlineStroke());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesStroke());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesFillPaint());
assertEquals(false, stackedXYAreaRenderer2_0.isOutline());
assertEquals(1, stackedXYAreaRenderer2_0.getPassCount());
assertEquals(2.0, stackedXYAreaRenderer2_0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(3, stackedXYAreaRenderer2_0.getDefaultEntityRadius());
assertEquals(true, stackedXYAreaRenderer2_0.getBaseSeriesVisible());
assertEquals(false, stackedXYAreaRenderer2_0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, stackedXYAreaRenderer2_0.getBaseSeriesVisibleInLegend());
assertEquals(false, jInternalFrame0.isPreferredSizeSet());
assertEquals(true, jInternalFrame0.isFocusTraversalPolicySet());
assertEquals(false, jInternalFrame0.isMinimumSizeSet());
assertEquals(false, jInternalFrame0.isVisible());
assertEquals(false, jInternalFrame0.isDisplayable());
assertEquals(true, jInternalFrame0.getFocusTraversalKeysEnabled());
assertEquals(false, jInternalFrame0.isValid());
assertEquals(false, jInternalFrame0.isFocusTraversalPolicyProvider());
assertEquals(2, jInternalFrame0.getComponentCount());
assertEquals(false, jInternalFrame0.getIgnoreRepaint());
assertEquals(true, jInternalFrame0.isBackgroundSet());
assertEquals(false, jInternalFrame0.isMaximumSizeSet());
assertEquals(true, jInternalFrame0.isEnabled());
assertEquals(false, jInternalFrame0.isLightweight());
assertEquals(false, jInternalFrame0.isFontSet());
assertEquals(false, jInternalFrame0.isForegroundSet());
assertEquals(false, jInternalFrame0.isCursorSet());
assertEquals(2, jInternalFrame0.countComponents());
assertEquals(false, jInternalFrame0.isShowing());
assertEquals(true, highLowRenderer0.getDrawCloseTicks());
assertEquals(3, highLowRenderer0.getDefaultEntityRadius());
assertEquals(false, highLowRenderer0.getBaseItemLabelsVisible());
assertEquals(true, highLowRenderer0.getBaseCreateEntities());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesStroke());
assertEquals(true, highLowRenderer0.getDrawOpenTicks());
assertEquals(true, highLowRenderer0.getBaseSeriesVisibleInLegend());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlinePaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesPaint());
assertEquals(true, highLowRenderer0.getAutoPopulateSeriesShape());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesOutlineStroke());
assertEquals(true, highLowRenderer0.getBaseSeriesVisible());
assertEquals(false, highLowRenderer0.getAutoPopulateSeriesFillPaint());
assertEquals(2.0, highLowRenderer0.getItemLabelAnchorOffset(), 0.01D);
assertEquals(1, highLowRenderer0.getPassCount());
assertEquals(0, rectangle0.width);
assertEquals(0, rectangle0.height);
assertEquals(0, rectangle0.x);
assertEquals(0, rectangle0.y);
}
@Test
public void test135() throws Throwable {
XYPlot xYPlot0 = new XYPlot();
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertNotNull(xYPlot0);
String string0 = xYPlot0.getPlotType();
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals("XY Plot", string0);
assertNotNull(string0);
int int0 = 65535;
SubCategoryAxis subCategoryAxis0 = new SubCategoryAxis(string0);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.2, subCategoryAxis0.getCategoryMargin(), 0.01D);
assertEquals(0.0, subCategoryAxis0.getFixedDimension(), 0.01D);
assertEquals(true, subCategoryAxis0.isTickLabelsVisible());
assertEquals(0.0, subCategoryAxis0.getLabelAngle(), 0.01D);
assertEquals(4, subCategoryAxis0.getCategoryLabelPositionOffset());
assertEquals(0.0F, subCategoryAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, subCategoryAxis0.isTickMarksVisible());
assertNull(subCategoryAxis0.getLabelURL());
assertEquals("XY Plot", subCategoryAxis0.getLabel());
assertEquals(2.0F, subCategoryAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, subCategoryAxis0.getMaximumCategoryLabelWidthRatio(), 0.01F);
assertEquals(0.05, subCategoryAxis0.getLowerMargin(), 0.01D);
assertNull(subCategoryAxis0.getLabelToolTip());
assertEquals(0.05, subCategoryAxis0.getUpperMargin(), 0.01D);
assertEquals(1, subCategoryAxis0.getMaximumCategoryLabelLines());
assertEquals(true, subCategoryAxis0.isAxisLineVisible());
assertEquals(true, subCategoryAxis0.isVisible());
assertNotNull(subCategoryAxis0);
CombinedDomainCategoryPlot combinedDomainCategoryPlot0 = new CombinedDomainCategoryPlot((CategoryAxis) subCategoryAxis0);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(0.2, subCategoryAxis0.getCategoryMargin(), 0.01D);
assertEquals(0.0, subCategoryAxis0.getFixedDimension(), 0.01D);
assertEquals(true, subCategoryAxis0.isTickLabelsVisible());
assertEquals(0.0, subCategoryAxis0.getLabelAngle(), 0.01D);
assertEquals(4, subCategoryAxis0.getCategoryLabelPositionOffset());
assertEquals(0.0F, subCategoryAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, subCategoryAxis0.isTickMarksVisible());
assertNull(subCategoryAxis0.getLabelURL());
assertEquals("XY Plot", subCategoryAxis0.getLabel());
assertEquals(2.0F, subCategoryAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, subCategoryAxis0.getMaximumCategoryLabelWidthRatio(), 0.01F);
assertEquals(0.05, subCategoryAxis0.getLowerMargin(), 0.01D);
assertNull(subCategoryAxis0.getLabelToolTip());
assertEquals(0.05, subCategoryAxis0.getUpperMargin(), 0.01D);
assertEquals(1, subCategoryAxis0.getMaximumCategoryLabelLines());
assertEquals(true, subCategoryAxis0.isAxisLineVisible());
assertEquals(true, subCategoryAxis0.isVisible());
assertNotNull(combinedDomainCategoryPlot0);
AxisLocation axisLocation0 = combinedDomainCategoryPlot0.getRangeAxisLocation(int0);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(0.2, subCategoryAxis0.getCategoryMargin(), 0.01D);
assertEquals(0.0, subCategoryAxis0.getFixedDimension(), 0.01D);
assertEquals(true, subCategoryAxis0.isTickLabelsVisible());
assertEquals(0.0, subCategoryAxis0.getLabelAngle(), 0.01D);
assertEquals(4, subCategoryAxis0.getCategoryLabelPositionOffset());
assertEquals(0.0F, subCategoryAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, subCategoryAxis0.isTickMarksVisible());
assertNull(subCategoryAxis0.getLabelURL());
assertEquals("XY Plot", subCategoryAxis0.getLabel());
assertEquals(2.0F, subCategoryAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, subCategoryAxis0.getMaximumCategoryLabelWidthRatio(), 0.01F);
assertEquals(0.05, subCategoryAxis0.getLowerMargin(), 0.01D);
assertNull(subCategoryAxis0.getLabelToolTip());
assertEquals(0.05, subCategoryAxis0.getUpperMargin(), 0.01D);
assertEquals(1, subCategoryAxis0.getMaximumCategoryLabelLines());
assertEquals(true, subCategoryAxis0.isAxisLineVisible());
assertEquals(true, subCategoryAxis0.isVisible());
assertEquals("AxisLocation.BOTTOM_OR_RIGHT", axisLocation0.toString());
assertNotNull(axisLocation0);
xYPlot0.setRangeAxisLocation(int0, axisLocation0);
assertEquals(0.5F, xYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(1.0F, xYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(true, xYPlot0.isRangeZoomable());
assertEquals(true, xYPlot0.isDomainCrosshairLockedOnData());
assertEquals(false, xYPlot0.isRangeCrosshairVisible());
assertEquals(1.0F, xYPlot0.getForegroundAlpha(), 0.01F);
assertEquals(0.0, xYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, xYPlot0.isOutlineVisible());
assertEquals(15, xYPlot0.getBackgroundImageAlignment());
assertEquals(1, xYPlot0.getWeight());
assertEquals(true, xYPlot0.isDomainGridlinesVisible());
assertEquals(0.0, xYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, xYPlot0.isSubplot());
assertEquals(false, xYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, xYPlot0.isRangeGridlinesVisible());
assertEquals(false, xYPlot0.isDomainCrosshairVisible());
assertNull(xYPlot0.getNoDataMessage());
assertEquals(false, xYPlot0.isDomainZeroBaselineVisible());
assertEquals(true, xYPlot0.isDomainZoomable());
assertEquals(true, xYPlot0.isRangeCrosshairLockedOnData());
assertEquals(1.0F, combinedDomainCategoryPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.isSubplot());
assertEquals(false, combinedDomainCategoryPlot0.getDrawSharedDomainAxis());
assertEquals(1.0F, combinedDomainCategoryPlot0.getForegroundAlpha(), 0.01F);
assertEquals(false, combinedDomainCategoryPlot0.isRangeCrosshairVisible());
assertEquals(0.0, combinedDomainCategoryPlot0.getAnchorValue(), 0.01D);
assertNull(combinedDomainCategoryPlot0.getNoDataMessage());
assertEquals(5.0, combinedDomainCategoryPlot0.getGap(), 0.01D);
assertEquals(true, combinedDomainCategoryPlot0.isRangeCrosshairLockedOnData());
assertEquals(0.0, combinedDomainCategoryPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedDomainCategoryPlot0.isDomainZoomable());
assertEquals(0.5F, combinedDomainCategoryPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(15, combinedDomainCategoryPlot0.getBackgroundImageAlignment());
assertEquals(true, combinedDomainCategoryPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedDomainCategoryPlot0.isOutlineVisible());
assertEquals(false, combinedDomainCategoryPlot0.isDomainGridlinesVisible());
assertEquals(0, combinedDomainCategoryPlot0.getWeight());
assertEquals(true, combinedDomainCategoryPlot0.isRangeZoomable());
assertEquals(0.2, subCategoryAxis0.getCategoryMargin(), 0.01D);
assertEquals(0.0, subCategoryAxis0.getFixedDimension(), 0.01D);
assertEquals(true, subCategoryAxis0.isTickLabelsVisible());
assertEquals(0.0, subCategoryAxis0.getLabelAngle(), 0.01D);
assertEquals(4, subCategoryAxis0.getCategoryLabelPositionOffset());
assertEquals(0.0F, subCategoryAxis0.getTickMarkInsideLength(), 0.01F);
assertEquals(false, subCategoryAxis0.isTickMarksVisible());
assertNull(subCategoryAxis0.getLabelURL());
assertEquals("XY Plot", subCategoryAxis0.getLabel());
assertEquals(2.0F, subCategoryAxis0.getTickMarkOutsideLength(), 0.01F);
assertEquals(0.0F, subCategoryAxis0.getMaximumCategoryLabelWidthRatio(), 0.01F);
assertEquals(0.05, subCategoryAxis0.getLowerMargin(), 0.01D);
assertNull(subCategoryAxis0.getLabelToolTip());
assertEquals(0.05, subCategoryAxis0.getUpperMargin(), 0.01D);
assertEquals(1, subCategoryAxis0.getMaximumCategoryLabelLines());
assertEquals(true, subCategoryAxis0.isAxisLineVisible());
assertEquals(true, subCategoryAxis0.isVisible());
assertEquals("AxisLocation.BOTTOM_OR_RIGHT", axisLocation0.toString());
}
@Test
public void test136() throws Throwable {
CombinedRangeXYPlot combinedRangeXYPlot0 = new CombinedRangeXYPlot();
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertNotNull(combinedRangeXYPlot0);
Color color0 = (Color)combinedRangeXYPlot0.getDomainCrosshairPaint();
assertEquals(true, combinedRangeXYPlot0.isRangeZoomable());
assertEquals(1.0F, combinedRangeXYPlot0.getBackgroundAlpha(), 0.01F);
assertEquals(false, combinedRangeXYPlot0.isDomainCrosshairVisible());
assertEquals(false, combinedRangeXYPlot0.isDomainZeroBaselineVisible());
assertEquals(1, combinedRangeXYPlot0.getWeight());
assertEquals(1.0F, combinedRangeXYPlot0.getForegroundAlpha(), 0.01F);
assertNull(combinedRangeXYPlot0.getNoDataMessage());
assertEquals(0.0, combinedRangeXYPlot0.getRangeCrosshairValue(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isRangeZeroBaselineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainZoomable());
assertEquals(true, combinedRangeXYPlot0.isRangeCrosshairLockedOnData());
assertEquals(15, combinedRangeXYPlot0.getBackgroundImageAlignment());
assertEquals(0.0, combinedRangeXYPlot0.getDomainCrosshairValue(), 0.01D);
assertEquals(true, combinedRangeXYPlot0.isDomainGridlinesVisible());
assertEquals(false, combinedRangeXYPlot0.isRangeCrosshairVisible());
assertEquals(5.0, combinedRangeXYPlot0.getGap(), 0.01D);
assertEquals(false, combinedRangeXYPlot0.isSubplot());
assertEquals(0.5F, combinedRangeXYPlot0.getBackgroundImageAlpha(), 0.01F);
assertEquals(true, combinedRangeXYPlot0.isRangeGridlinesVisible());
assertEquals(true, combinedRangeXYPlot0.isOutlineVisible());
assertEquals(true, combinedRangeXYPlot0.isDomainCrosshairLockedOnData());
assertEquals(255, color0.getAlpha());
assertEquals(255, color0.getBlue());
assertEquals(1, color0.getTransparency());
assertEquals(-16776961, color0.getRGB());
assertEquals(0, color0.getGreen());
assertEquals("java.awt.Color[r=0,g=0,b=255]", color0.toString());
assertEquals(0, color0.getRed());
assertNotNull(color0);
}
}
| [
"martin.monperrus@gnieh.org"
] | martin.monperrus@gnieh.org |
638b363499dc26c14c3021756a144dfc37b00aa4 | 23458bdfb7393433203985569e68bc1935a022d6 | /NDC-GraphQL-Client/src/generated-sources/java/org/iata/oo/schema/AirShoppingRS/AgencyIDType.java | c9a1561bb5873d213ace8c74b5a08c721a780f77 | [] | no_license | joelmorales/NDC | 7c6baa333c0285b724e6356bd7ae808f1f74e7ec | ebddd30369ec74e078a2c9996da0402f9ac448a1 | refs/heads/master | 2021-06-30T02:49:12.522375 | 2019-06-13T14:55:05 | 2019-06-13T14:55:05 | 171,594,242 | 1 | 0 | null | 2020-10-13T12:03:33 | 2019-02-20T03:29:16 | Java | UTF-8 | Java | false | false | 1,111 | java | //
// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.7
// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
// Any modifications to this file will be lost upon recompilation of the source schema.
// Generated on: 2019.03.05 at 04:34:49 PM CST
//
package org.iata.oo.schema.AirShoppingRS;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;
/**
* A data type for Agency (Seller) ID.
*
* <p>Java class for AgencyID_Type complex type.
*
* <p>The following schema fragment specifies the expected content contained within this class.
*
* <pre>
* <complexType name="AgencyID_Type">
* <simpleContent>
* <extension base="<http://www.iata.org/IATA/EDIST/2017.2>UniqueIDContextType">
* </extension>
* </simpleContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "AgencyID_Type")
public class AgencyIDType
extends UniqueIDContextType
{
}
| [
"joel.moralesmorales@hotmail.com"
] | joel.moralesmorales@hotmail.com |
144de7f8863c4b1b0cbad191a1acd6b8d446ba7c | 80dbd191f10366b937054c8fca2adab5f9dcaa88 | /Kolokvij/GUIDrzaveEdit.java | deb661469e3f35e4b5f119eac4cb0f57a54e7d9b | [] | no_license | JureZajc/Java_ListOfCountries | 182fa376b6c6ff7f3c67e908cbf27f51323f2ad3 | f84577aec10a877939260f330555c9a2144557ea | refs/heads/master | 2020-03-08T17:38:42.738597 | 2018-04-06T08:40:16 | 2018-04-06T08:40:16 | 128,274,231 | 0 | 0 | null | null | null | null | WINDOWS-1250 | Java | false | false | 3,888 | java | import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.border.EmptyBorder;
import java.awt.GridLayout;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.SwingConstants;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
public class GUIDrzaveEdit extends JFrame {
private JPanel panOsnovna;
private JTextField txtDrzavaSLO;
private JTextField txtDrzavaISO;
private JTextField txtOznaka2;
private JTextField txtOznaka3;
private JTextArea taOpombe;
private JButton btnShrani;
private JButton btnPreklici;
private Drzave zapisDrzava;
private DrzaveSQL drzaveSQL;
public GUIDrzaveEdit() {
setResizable(false);
setTitle("Država");
setBounds(100, 100, 691, 300);
panOsnovna = new JPanel();
panOsnovna.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(panOsnovna);
panOsnovna.setLayout(new GridLayout(6, 2, 5, 5));
JLabel lblDrzavaSlo = new JLabel("Država (SLO)");
lblDrzavaSlo.setHorizontalAlignment(SwingConstants.CENTER);
panOsnovna.add(lblDrzavaSlo);
txtDrzavaSLO = new JTextField();
txtDrzavaSLO.setColumns(120);// na kaj ima to vpliv? Ker v bazi je 250 vpisov
panOsnovna.add(txtDrzavaSLO);
JLabel lblDrzavaISO = new JLabel("Država (ISO)");
lblDrzavaISO.setHorizontalAlignment(SwingConstants.CENTER);
panOsnovna.add(lblDrzavaISO);
txtDrzavaISO = new JTextField();
txtDrzavaISO.setColumns(120);
panOsnovna.add(txtDrzavaISO);
JLabel lblOznaka2 = new JLabel("Oznaka (2)");
lblOznaka2.setHorizontalAlignment(SwingConstants.CENTER);
panOsnovna.add(lblOznaka2);
txtOznaka2 = new JTextField();
txtOznaka2.setColumns(2);
panOsnovna.add(txtOznaka2);
JLabel lblOznaka3 = new JLabel("Oznaka (3)");
lblOznaka3.setHorizontalAlignment(SwingConstants.CENTER);
panOsnovna.add(lblOznaka3);
txtOznaka3 = new JTextField();
txtOznaka3.setColumns(3);
panOsnovna.add(txtOznaka3);
JLabel lblOpombe = new JLabel("Opombe");
lblOpombe.setHorizontalAlignment(SwingConstants.CENTER);
panOsnovna.add(lblOpombe);
taOpombe = new JTextArea();
JScrollPane spOpombe = new JScrollPane(taOpombe);
panOsnovna.add(spOpombe);
JLabel lblAktivnosti = new JLabel("");
panOsnovna.add(lblAktivnosti);
JPanel panGumbi = new JPanel();
panOsnovna.add(panGumbi);
btnShrani = new JButton("Shrani");
btnShrani.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
zapisDrzava.setDrzavaSlo(txtDrzavaSLO.getText());
zapisDrzava.setDrzavaIso(txtDrzavaISO.getText());
zapisDrzava.setOznakaDvomestna(txtOznaka2.getText());
zapisDrzava.setOznakaTromestna(txtOznaka3.getText());
zapisDrzava.setOpomba(taOpombe.getText());
drzaveSQL.spremeniDrzave(zapisDrzava.getDrzavaSlo(), zapisDrzava.getDrzavaIso(), zapisDrzava.getOznakaDvomestna(), zapisDrzava.getOznakaTromestna(), zapisDrzava.getOpomba(), zapisDrzava.getIdDrzave() );
dispose(); // zapremo in počistimo vir okna
}
});
panGumbi.add(btnShrani);
btnPreklici = new JButton("Prekliči");
btnPreklici.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
dispose();
}
});
panGumbi.add(btnPreklici);
} // konstruktor
public void dolociVrednosti(Drzave drzava, DrzaveSQL drzaveSQL) {
zapisDrzava = drzava;
txtDrzavaSLO.setText(drzava.getDrzavaSlo());
txtDrzavaISO.setText(drzava.getDrzavaIso());
txtOznaka2.setText(drzava.getOznakaDvomestna());
txtOznaka3.setText(drzava.getOznakaTromestna());
taOpombe.setText(drzava.getOpomba());
this.drzaveSQL = drzaveSQL;
}
public Drzave getZapisDrzave() {
return zapisDrzava;
}
} // razred GUIDrzaveEdit
| [
"33668407+JureZajc@users.noreply.github.com"
] | 33668407+JureZajc@users.noreply.github.com |
5c97735aad995622dcca2a5b8e54547eb61c703b | 3d8c12f9e007cc5160ee8768b26f77fa3876e5b3 | /src/test/java/com/innvo/cucumber/CucumberIT.java | 0d7959aee484f358e95c0794bd67522c47be568f | [] | no_license | skywriter-systems/camunda-gateway | 96f6b8f68d71cb3470242dc532b041ec68a77e8a | 098987770411b46e0204630be2b171b605d7297c | refs/heads/master | 2022-07-31T23:23:04.521742 | 2019-09-16T13:58:24 | 2019-09-16T13:58:24 | 208,491,669 | 0 | 0 | null | 2022-07-07T12:19:50 | 2019-09-14T19:19:34 | Java | UTF-8 | Java | false | false | 260 | java | package com.innvo.cucumber;
import org.junit.runner.RunWith;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;
@RunWith(Cucumber.class)
@CucumberOptions(plugin = "pretty", features = "src/test/features")
public class CucumberIT {
}
| [
"echasin@innvosolutions.com"
] | echasin@innvosolutions.com |
f8bc54747888fb5f84edf7253391edc64caf3cde | 770f6415a0638715f010482130f060896323bf7a | /src/chord/project/AbstractStepCollection.java | 1b7491e097936711f4119b8adf89f70db37fcc1f | [] | no_license | damianozanardini/java-heap-analyzer | a710babae31c246529e3377129290bdb28ab21e9 | ea89a7ccc4176e664320aa6e7e215d1f26d31db3 | refs/heads/master | 2020-12-02T16:14:24.368264 | 2017-09-12T21:05:40 | 2017-09-12T21:05:40 | 96,521,047 | 4 | 1 | null | null | null | null | UTF-8 | Java | false | false | 1,592 | java | package chord.project;
import java.util.List;
// abstract since does not implement the run(Object ctrl) method
public abstract class AbstractStepCollection implements IStepCollection {
protected String name;
protected List<IDataCollection> consumedDataCollections;
protected List<IDataCollection> producedDataCollections;
protected List<ICtrlCollection> producedCtrlCollections;
protected ICtrlCollection prescribingCollection;
@Override
public void setName(String name) {
this.name = name;
}
@Override
public String getName() {
return name;
}
@Override
public void setPrescribingCollection(ICtrlCollection c) {
prescribingCollection = c;
}
@Override
public ICtrlCollection getPrescribingCollection() {
return prescribingCollection;
}
@Override
public void setConsumedDataCollections(List<IDataCollection> c) {
consumedDataCollections = c;
}
@Override
public List<IDataCollection> getConsumedDataCollections() {
return consumedDataCollections;
}
@Override
public void setProducedDataCollections(List<IDataCollection> c) {
producedDataCollections = c;
}
@Override
public List<IDataCollection> getProducedDataCollections() {
return producedDataCollections;
}
@Override
public void setProducedCtrlCollections(List<ICtrlCollection> c) {
producedCtrlCollections = c;
}
@Override
public List<ICtrlCollection> getProducedCtrlCollections() {
return producedCtrlCollections;
}
}
| [
"damiano.zanardini@gmail.com"
] | damiano.zanardini@gmail.com |
5d2a01f0cbd52747dfff6ca3c4fa0591f7bbf981 | b7cb036af93dbbc84dab7932034695c9c5f516e3 | /src/main/java/kr/or/ddit/basic/BasicServlet.java | bb284fa4be379a1f5b29c507008cd507ae868488 | [] | no_license | fmfhfmfh/jsp | 28a394ea57760b4b22e821d7b2716334c1c99ddf | b5ac8558f85cfcc9d9b897587c6d7d02069847a6 | refs/heads/master | 2023-01-19T15:04:02.585765 | 2020-10-22T11:36:16 | 2020-10-22T11:36:16 | 298,155,361 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,162 | java | package kr.or.ddit.basic;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 서블릿을 생성하는 방법
// 1. HttpServlet 클래스를 상속한다
// 2. doXXX 메서드를 구현한다
// 3. servlet은 정적 자료와 다르게 이름이 없다
// localhost/ServletTest/index.html
// localhost/BasicServlet.java
// url - 서블릿 매핑하는 작업
// url을 직접 이름을 생성해줘야 한다 (web.xml)
public class BasicServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("text/html; charset=UTF-8");
// writer 객체를 통해 html 문서를 생성해준다
PrintWriter writer = resp.getWriter();
writer.println("<html>");
writer.println(" <head></head>");
writer.println(" <body>현재시간 : " + new Date() + "</body>");
writer.println("</html>");
writer.flush();
writer.close();
}
}
| [
"fmfhfmfh@gmail.com"
] | fmfhfmfh@gmail.com |
0f57a1b5bddd35f9b7e333f0edbd7a68c7e17fd3 | d1b386c98d392b8d8f1f652f32394e80d698c213 | /src/main/java/br/com/zaratech/controller/GestaoFinanceiraController.java | 4f8b9718f7be31a7f828bd78c49819356884c7fd | [] | no_license | guizaramellaf91/tattools | c4f97de17abe131422c341dddf07423c8c98701b | d9d74dc079bc9c96dfd7ef17ac573e80a3d7366c | refs/heads/master | 2023-01-14T08:16:59.638649 | 2020-11-18T01:50:30 | 2020-11-18T01:50:30 | 277,210,338 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,761 | java | package br.com.zaratech.controller;
import java.util.Optional;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;
import br.com.zaratech.service.GestaoFinanceiraService;
@Controller
public class GestaoFinanceiraController {
static Logger log = Logger.getLogger(GestaoFinanceiraController.class);
@Autowired
private GestaoFinanceiraService gestaoFinanceiraService;
@RequestMapping(value = "/gestaoFinanceira", method = RequestMethod.GET)
public ModelAndView gestaoFinanceira(@RequestParam("pageSize") Optional<Integer> pageSize,
@RequestParam("page") Optional<Integer> page) {
return gestaoFinanceiraService.gestaoFinanceira(pageSize, page);
}
@RequestMapping(value = "detalhesGestaoFinanceiraOS/{ordemServicoId}", method = RequestMethod.GET)
public ModelAndView detalhesGestaoFinanceiraOS(@PathVariable(value = "ordemServicoId", required = false) long ordemServicoId) {
return gestaoFinanceiraService.detalhesGestaoFinanceiraOS(ordemServicoId);
}
@RequestMapping(value = "efetuarRecebimentoGestaoFinanceira", method = RequestMethod.POST)
public ModelAndView efetuarRecebimentoGestaoFinanceira(long gestaoFinanceiraId, boolean recebeDinheiro, boolean recebeDebito, boolean recebeCredito) {
return gestaoFinanceiraService.efetuarRecebimentoGestaoFinanceira(gestaoFinanceiraId, recebeDinheiro, recebeDebito, recebeCredito);
}
} | [
"guizaramellaf91@gmail.com"
] | guizaramellaf91@gmail.com |
b72b226a43f5a6d02b34dfe1425b91f82de3dc95 | 1a281e1f522f64d891ed28853de5dc904897d327 | /src/main/java/employeeHomeWork/Main.java | 214b88fea93f5a1c1cbe5c64a7a8ab36a2f031b8 | [] | no_license | avonteCannon/weekwork | 41c8ec32976942c48a8033edd267789adbb91a14 | d30ad1af605908426382383854e89be86f879b25 | refs/heads/master | 2020-05-04T12:01:00.014128 | 2019-04-03T14:51:24 | 2019-04-03T14:51:24 | 179,119,848 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 408 | java | package employeeHomeWork;
public class Main {
public static void main(String[] args) {
Employee myEmployee = new Employee();
myEmployee.setName("Avonte");
myEmployee.setSalary(60000);
myEmployee.getName();
myEmployee.getSalary();
System.out.println(myEmployee.raiseSalary(2000));
System.out.println(myEmployee.printName("Avonte", "GQ"));
}
}
| [
"acannon007@my.wilmu.edu"
] | acannon007@my.wilmu.edu |
73b3ef7d9535cc88e75ef2a43a09d4a41845a44d | f2abd88aeb49c0bb58370354b1b06c02896f8190 | /src/main/java/iq/kurd/com/exception/MsgException.java | 903ad134ad3b4d2594126ed478e766a7cbe6f672 | [] | no_license | jinkookjeong/KURD | 3b865553175b2f79d25d484732027861d54f9154 | a4f83a1602ea12e0df37f9e46e91f2719d54cf82 | refs/heads/master | 2020-04-09T04:54:27.655479 | 2018-12-04T11:57:48 | 2018-12-04T11:57:48 | 158,838,276 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 372 | java | package iq.kurd.com.exception;
/**
* 화면에 에러 메세지 전달용
* @author jwchoi
*
*/
public class MsgException extends Exception {
private static final long serialVersionUID = -3029187880941733652L;
public MsgException(String msg){
super(msg);
}
public MsgException(String msg, Throwable cause){
super(msg, cause);
}
}
| [
"user@user-PC"
] | user@user-PC |
c6932154abd2a1946529560fed766cec8a6ef772 | 4169b99b36cbc1764c56c02598769e5bd69b2164 | /src/Asignatura.java | 1b23308796ac82d362568128e635f575b3bc0960 | [] | no_license | Nizar4790k/JUniversidad | adf7a1f3cbec6584ae39aadcd8a234dba962c61c | 26588ee4e8df3a2568522b427b5668591845aa5a | refs/heads/master | 2023-04-15T12:38:51.437528 | 2021-04-30T00:46:16 | 2021-04-30T00:46:16 | 362,668,520 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,165 | java | import java.util.List;
import java.util.Scanner;
public class Asignatura {
public static final int PRECIO_POR_CREDITO= 500;
private static final Asignatura[] asignaturas= {
new Asignatura("Fisica Basica",4),
new Asignatura("Matematica Basica",5),
new Asignatura("Filosofia 1",3),
new Asignatura("Biologia Basica",3),
new Asignatura("Laboratorio de Fisica Basica",1),
new Asignatura("Metodologia de la investigacion cientifica",3),
new Asignatura("Lengua Espanola",4),
new Asignatura("Programacion Estructurada",4)
};
private String nombre;
private int creditos;
public Asignatura(String nombre, int creditos) {
this.nombre = nombre;
this.creditos = creditos;
}
public String getNombre() {
return nombre;
}
public int getCreditos() {
return creditos;
}
@Override
public String toString() {
return getNombre()+" ("+getCreditos()+" creditos )";
}
public static void consultarAsignaturas(Estudiante estudiante){
List<Asignatura> asignaturas = estudiante.getAsignaturas();
for(Asignatura asignatura:asignaturas){
System.out.println("Nombre de la asignatura: "+asignatura.getNombre());
System.out.println("Cantidad de creditos de la asignatura: "+asignatura.getCreditos()+"\n");
}
}
public static void seleccionarAsignatura(Estudiante estudiante){
Scanner scanner = new Scanner(System.in);
System.out.println("Seleccione una asignatura");
for (int i=0;i<asignaturas.length;i++){
System.out.println((i+1)+"."+asignaturas[i]);
}
int opcion = Integer.parseInt(scanner.nextLine());
if (opcion>0 && opcion<=asignaturas.length){
estudiante.agregarAsignatura(asignaturas[opcion-1]);
System.out.println("Ha seleccionado la asignatura "+asignaturas[opcion-1]+" con exito!"+"\n");
}else{
System.out.println("Opcion incorrecta");
seleccionarAsignatura(estudiante);
}
}
}
| [
"nizar4790k@gmail.com"
] | nizar4790k@gmail.com |
cc260bd92a4ef77fc31a3dbd384d78977746db03 | 4cdf169e3a6cdb8b6bedba66cf0cc4b37ebd282a | /Home-Security-Identifier/src/main/java/Images.java | 31d58865303dac2466c57acbef59d4730b34329e | [] | no_license | tomzyzhu/Home-Security-Identifier-Java | f743f3642aa9ecdcdc7e750c251d9e97400bcf0b | 97be983aeb1e46e3ad0e3043b39553bae13cba9c | refs/heads/master | 2020-04-16T05:43:36.491828 | 2019-01-14T06:07:49 | 2019-01-14T06:07:49 | 165,128,356 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 588 | java |
public class Images
{
private Classifiers[] classifiers;
private String image;
public Classifiers[] getClassifiers ()
{
return classifiers;
}
public void setClassifiers (Classifiers[] classifiers)
{
this.classifiers = classifiers;
}
public String getImage ()
{
return image;
}
public void setImage (String image)
{
this.image = image;
}
@Override
public String toString()
{
return "ClassPojo [classifiers = "+classifiers+", image = "+image+"]";
}
}
| [
"tzzhu@edu.uwaterloo.ca"
] | tzzhu@edu.uwaterloo.ca |
6598edab1dcac6f9853e4198327c3bada285e303 | 22b57568dad3db4949056f783bf5f5d78aaa9ca4 | /src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/SectionInfo.java | 386e3f46d92957fff7a59a48b41072d425856c01 | [
"MIT"
] | permissive | icedland/iced | d2178ea519c1472fb9c70c39c3a2f6428dc0d855 | 71f6d8372703e2487a973e0ad871a78348f63f8d | refs/heads/master | 2023-08-31T12:01:21.264077 | 2023-08-30T18:03:52 | 2023-08-30T18:03:52 | 147,866,440 | 1,446 | 128 | MIT | 2023-09-05T17:24:21 | 2018-09-07T19:30:25 | Rust | UTF-8 | Java | false | false | 403 | java | // SPDX-License-Identifier: MIT
// Copyright (C) 2018-present iced project and contributors
package com.github.icedland.iced.x86;
import java.util.function.BiConsumer;
public final class SectionInfo {
public final String name;
public final BiConsumer<String, String> handler;
public SectionInfo(String name, BiConsumer<String, String> handler) {
this.name = name;
this.handler = handler;
}
}
| [
"wtfsck@protonmail.com"
] | wtfsck@protonmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.